@rjsf/utils 5.9.0 → 5.11.1

package/dist/utils.umd.development.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash-es/isPlainObject'), require('lodash-es/isEqualWith'), require('lodash-es/get'), require('lodash-es/isEmpty'), require('jsonpointer'), require('lodash-es/omit'), require('lodash-es/has'), require('lodash-es/isObject'), require('lodash-es/isString'), require('lodash-es/reduce'), require('lodash-es/times'), require('lodash-es/set'), require('json-schema-merge-allof'), require('lodash-es/union'), require('lodash-es/isEqual'), require('lodash-es'), require('lodash-es/cloneDeep'), require('react/jsx-runtime'), require('react'), require('react-is'), require('lodash-es/toPath'), require('lodash-es/forEach')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash-es/isPlainObject', 'lodash-es/isEqualWith', 'lodash-es/get', 'lodash-es/isEmpty', 'jsonpointer', 'lodash-es/omit', 'lodash-es/has', 'lodash-es/isObject', 'lodash-es/isString', 'lodash-es/reduce', 'lodash-es/times', 'lodash-es/set', 'json-schema-merge-allof', 'lodash-es/union', 'lodash-es/isEqual', 'lodash-es', 'lodash-es/cloneDeep', 'react/jsx-runtime', 'react', 'react-is', 'lodash-es/toPath', 'lodash-es/forEach'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject, global.isEqualWith, global.get, global.isEmpty, global.jsonpointer, global.omit, global.has, global.isObject$1, global.isString, global.reduce, global.times, global.set, global.mergeAllOf, global.union, global.isEqual, global.lodashEs, global.cloneDeep, global.jsxRuntime, global.React, global.ReactIs, global.toPath, global.forEach));
-})(this, (function (exports, isPlainObject, isEqualWith, get, isEmpty, jsonpointer, omit, has, isObject$1, isString, reduce, times, set, mergeAllOf, union, isEqual, lodashEs, cloneDeep, jsxRuntime, react, ReactIs, toPath, forEach) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash-es/isPlainObject'), require('lodash-es/isEqualWith'), require('lodash-es/get'), require('lodash-es/isEmpty'), require('jsonpointer'), require('lodash-es/omit'), require('lodash-es/has'), require('lodash-es/isObject'), require('lodash-es/isString'), require('lodash-es/reduce'), require('lodash-es/times'), require('lodash-es/set'), require('lodash-es/forEach'), require('json-schema-merge-allof'), require('lodash-es/union'), require('lodash-es/isEqual'), require('lodash-es'), require('lodash-es/cloneDeep'), require('react/jsx-runtime'), require('react'), require('react-is'), require('lodash-es/toPath')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'lodash-es/isPlainObject', 'lodash-es/isEqualWith', 'lodash-es/get', 'lodash-es/isEmpty', 'jsonpointer', 'lodash-es/omit', 'lodash-es/has', 'lodash-es/isObject', 'lodash-es/isString', 'lodash-es/reduce', 'lodash-es/times', 'lodash-es/set', 'lodash-es/forEach', 'json-schema-merge-allof', 'lodash-es/union', 'lodash-es/isEqual', 'lodash-es', 'lodash-es/cloneDeep', 'react/jsx-runtime', 'react', 'react-is', 'lodash-es/toPath'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject, global.isEqualWith, global.get, global.isEmpty, global.jsonpointer, global.omit, global.has, global.isObject$1, global.isString, global.reduce, global.times, global.set, global.forEach, global.mergeAllOf, global.union, global.isEqual, global.lodashEs, global.cloneDeep, global.jsxRuntime, global.React, global.ReactIs, global.toPath));
+})(this, (function (exports, isPlainObject, isEqualWith, get, isEmpty, jsonpointer, omit, has, isObject$1, isString, reduce, times, set, forEach, mergeAllOf, union, isEqual, lodashEs, cloneDeep, jsxRuntime, react, ReactIs, toPath) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -18,13 +18,13 @@
   var reduce__default = /*#__PURE__*/_interopDefaultLegacy(reduce);
   var times__default = /*#__PURE__*/_interopDefaultLegacy(times);
   var set__default = /*#__PURE__*/_interopDefaultLegacy(set);
+  var forEach__default = /*#__PURE__*/_interopDefaultLegacy(forEach);
   var mergeAllOf__default = /*#__PURE__*/_interopDefaultLegacy(mergeAllOf);
   var union__default = /*#__PURE__*/_interopDefaultLegacy(union);
   var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
   var cloneDeep__default = /*#__PURE__*/_interopDefaultLegacy(cloneDeep);
   var ReactIs__default = /*#__PURE__*/_interopDefaultLegacy(ReactIs);
   var toPath__default = /*#__PURE__*/_interopDefaultLegacy(toPath);
-  var forEach__default = /*#__PURE__*/_interopDefaultLegacy(forEach);
 
   /** Determines whether a `thing` is an object for the purposes of RSJF. In this case, `thing` is an object if it has
    * the type `object` but is NOT null, an array or a File.
@@ -86,103 +86,42 @@
       // specific precision or number of significant digits)
       return value;
     }
-    var n = Number(value);
-    var valid = typeof n === 'number' && !Number.isNaN(n);
+    const n = Number(value);
+    const valid = typeof n === 'number' && !Number.isNaN(n);
     return valid ? n : value;
   }
 
-  function _defineProperties(target, props) {
-    for (var i = 0; i < props.length; i++) {
-      var descriptor = props[i];
-      descriptor.enumerable = descriptor.enumerable || false;
-      descriptor.configurable = true;
-      if ("value" in descriptor) descriptor.writable = true;
-      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
-    }
-  }
-  function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    Object.defineProperty(Constructor, "prototype", {
-      writable: false
-    });
-    return Constructor;
-  }
-  function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
-      }
-      return target;
-    };
-    return _extends.apply(this, arguments);
-  }
-  function _objectDestructuringEmpty(obj) {
-    if (obj == null) throw new TypeError("Cannot destructure " + obj);
-  }
-  function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for (i = 0; i < sourceKeys.length; i++) {
-      key = sourceKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      target[key] = source[key];
-    }
-    return target;
-  }
-  function _toPrimitive(input, hint) {
-    if (typeof input !== "object" || input === null) return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== undefined) {
-      var res = prim.call(input, hint || "default");
-      if (typeof res !== "object") return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return (hint === "string" ? String : Number)(input);
-  }
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return typeof key === "symbol" ? key : String(key);
-  }
-
   /** Below are the list of all the keys into various elements of a RJSFSchema or UiSchema that are used by the various
    * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG` and
    * `RJSF_ADDITONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
    * utility.
    */
-  var ADDITIONAL_PROPERTY_FLAG = '__additional_property';
-  var ADDITIONAL_PROPERTIES_KEY = 'additionalProperties';
-  var ALL_OF_KEY = 'allOf';
-  var ANY_OF_KEY = 'anyOf';
-  var CONST_KEY = 'const';
-  var DEFAULT_KEY = 'default';
-  var DEFINITIONS_KEY = 'definitions';
-  var DEPENDENCIES_KEY = 'dependencies';
-  var ENUM_KEY = 'enum';
-  var ERRORS_KEY = '__errors';
-  var ID_KEY = '$id';
-  var IF_KEY = 'if';
-  var ITEMS_KEY = 'items';
-  var JUNK_OPTION_ID = '_$junk_option_schema_id$_';
-  var NAME_KEY = '$name';
-  var ONE_OF_KEY = 'oneOf';
-  var PROPERTIES_KEY = 'properties';
-  var REQUIRED_KEY = 'required';
-  var SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
-  var REF_KEY = '$ref';
-  var RJSF_ADDITONAL_PROPERTIES_FLAG = '__rjsf_additionalProperties';
-  var ROOT_SCHEMA_PREFIX = '__rjsf_rootSchema';
-  var UI_FIELD_KEY = 'ui:field';
-  var UI_WIDGET_KEY = 'ui:widget';
-  var UI_OPTIONS_KEY = 'ui:options';
-  var UI_GLOBAL_OPTIONS_KEY = 'ui:globalOptions';
+  const ADDITIONAL_PROPERTY_FLAG = '__additional_property';
+  const ADDITIONAL_PROPERTIES_KEY = 'additionalProperties';
+  const ALL_OF_KEY = 'allOf';
+  const ANY_OF_KEY = 'anyOf';
+  const CONST_KEY = 'const';
+  const DEFAULT_KEY = 'default';
+  const DEFINITIONS_KEY = 'definitions';
+  const DEPENDENCIES_KEY = 'dependencies';
+  const ENUM_KEY = 'enum';
+  const ERRORS_KEY = '__errors';
+  const ID_KEY = '$id';
+  const IF_KEY = 'if';
+  const ITEMS_KEY = 'items';
+  const JUNK_OPTION_ID = '_$junk_option_schema_id$_';
+  const NAME_KEY = '$name';
+  const ONE_OF_KEY = 'oneOf';
+  const PROPERTIES_KEY = 'properties';
+  const REQUIRED_KEY = 'required';
+  const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
+  const REF_KEY = '$ref';
+  const RJSF_ADDITONAL_PROPERTIES_FLAG = '__rjsf_additionalProperties';
+  const ROOT_SCHEMA_PREFIX = '__rjsf_rootSchema';
+  const UI_FIELD_KEY = 'ui:field';
+  const UI_WIDGET_KEY = 'ui:widget';
+  const UI_OPTIONS_KEY = 'ui:options';
+  const UI_GLOBAL_OPTIONS_KEY = 'ui:globalOptions';
 
   /** Get all passed options from ui:options, and ui:<optionName>, returning them in an object with the `ui:`
    * stripped off. Any `globalOptions` will always be returned, unless they are overridden by options in the `uiSchema`.
@@ -191,27 +130,26 @@
    * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
    * @returns - An object containing all the `ui:xxx` options with the `ui:` stripped off along with all `globalOptions`
    */
-  function getUiOptions(uiSchema, globalOptions) {
-    if (uiSchema === void 0) {
-      uiSchema = {};
-    }
-    if (globalOptions === void 0) {
-      globalOptions = {};
-    }
-    return Object.keys(uiSchema).filter(function (key) {
-      return key.indexOf('ui:') === 0;
-    }).reduce(function (options, key) {
-      var _extends2;
-      var value = uiSchema[key];
+  function getUiOptions(uiSchema = {}, globalOptions = {}) {
+    return Object.keys(uiSchema).filter(key => key.indexOf('ui:') === 0).reduce((options, key) => {
+      const value = uiSchema[key];
       if (key === UI_WIDGET_KEY && isObject(value)) {
         console.error('Setting options via ui:widget object is no longer supported, use ui:options instead');
         return options;
       }
       if (key === UI_OPTIONS_KEY && isObject(value)) {
-        return _extends({}, options, value);
+        return {
+          ...options,
+          ...value
+        };
       }
-      return _extends({}, options, (_extends2 = {}, _extends2[key.substring(3)] = value, _extends2));
-    }, _extends({}, globalOptions));
+      return {
+        ...options,
+        [key.substring(3)]: value
+      };
+    }, {
+      ...globalOptions
+    });
   }
 
   /** Checks whether the field described by `schema`, having the `uiSchema` and `formData` supports expanding. The UI for
@@ -223,16 +161,13 @@
    * @param [formData] - The formData for the field
    * @returns - True if the schema element has additionalProperties, is expandable, and not at the maxProperties limit
    */
-  function canExpand(schema, uiSchema, formData) {
-    if (uiSchema === void 0) {
-      uiSchema = {};
-    }
+  function canExpand(schema, uiSchema = {}, formData) {
     if (!schema.additionalProperties) {
       return false;
     }
-    var _getUiOptions = getUiOptions(uiSchema),
-      _getUiOptions$expanda = _getUiOptions.expandable,
-      expandable = _getUiOptions$expanda === void 0 ? true : _getUiOptions$expanda;
+    const {
+      expandable = true
+    } = getUiOptions(uiSchema);
     if (expandable === false) {
       return expandable;
     }
@@ -250,21 +185,30 @@
    * @returns - A `FormValidation` object based on the `formData` structure
    */
   function createErrorHandler(formData) {
-    var _handler;
-    var handler = (_handler = {}, _handler[ERRORS_KEY] = [], _handler.addError = function addError(message) {
-      this[ERRORS_KEY].push(message);
-    }, _handler);
+    const handler = {
+      // We store the list of errors for this node in a property named __errors
+      // to avoid name collision with a possible sub schema field named
+      // 'errors' (see `utils.toErrorSchema`).
+      [ERRORS_KEY]: [],
+      addError(message) {
+        this[ERRORS_KEY].push(message);
+      }
+    };
     if (Array.isArray(formData)) {
-      return formData.reduce(function (acc, value, key) {
-        var _extends2;
-        return _extends({}, acc, (_extends2 = {}, _extends2[key] = createErrorHandler(value), _extends2));
+      return formData.reduce((acc, value, key) => {
+        return {
+          ...acc,
+          [key]: createErrorHandler(value)
+        };
       }, handler);
     }
     if (isPlainObject__default["default"](formData)) {
-      var formObject = formData;
-      return Object.keys(formObject).reduce(function (acc, key) {
-        var _extends3;
-        return _extends({}, acc, (_extends3 = {}, _extends3[key] = createErrorHandler(formObject[key]), _extends3));
+      const formObject = formData;
+      return Object.keys(formObject).reduce((acc, key) => {
+        return {
+          ...acc,
+          [key]: createErrorHandler(formObject[key])
+        };
       }, handler);
     }
     return handler;
@@ -278,7 +222,7 @@
    * @returns - True if the `a` and `b` are deeply equal, false otherwise
    */
   function deepEquals(a, b) {
-    return isEqualWith__default["default"](a, b, function (obj, other) {
+    return isEqualWith__default["default"](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
@@ -297,8 +241,8 @@
    *      value from `object[key]`
    */
   function splitKeyElementFromObject(key, object) {
-    var value = object[key];
-    var remaining = omit__default["default"](object, [key]);
+    const value = object[key];
+    const remaining = omit__default["default"](object, [key]);
     return [remaining, value];
   }
   /** Given the name of a `$ref` from within a schema, using the `rootSchema`, look up and return the sub-schema using the
@@ -310,28 +254,26 @@
    * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
    * @throws - Error indicating that no schema for that reference exists
    */
-  function findSchemaDefinition($ref, rootSchema) {
-    if (rootSchema === void 0) {
-      rootSchema = {};
-    }
-    var ref = $ref || '';
+  function findSchemaDefinition($ref, rootSchema = {}) {
+    let ref = $ref || '';
     if (ref.startsWith('#')) {
       // Decode URI fragment representation.
       ref = decodeURIComponent(ref.substring(1));
     } else {
-      throw new Error("Could not find a definition for " + $ref + ".");
+      throw new Error(`Could not find a definition for ${$ref}.`);
     }
-    var current = jsonpointer__default["default"].get(rootSchema, ref);
+    const current = jsonpointer__default["default"].get(rootSchema, ref);
     if (current === undefined) {
-      throw new Error("Could not find a definition for " + $ref + ".");
+      throw new Error(`Could not find a definition for ${$ref}.`);
     }
     if (current[REF_KEY]) {
-      var _splitKeyElementFromO = splitKeyElementFromObject(REF_KEY, current),
-        remaining = _splitKeyElementFromO[0],
-        theRef = _splitKeyElementFromO[1];
-      var subSchema = findSchemaDefinition(theRef, rootSchema);
+      const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
+      const subSchema = findSchemaDefinition(theRef, rootSchema);
       if (Object.keys(remaining).length > 0) {
-        return _extends({}, remaining, subSchema);
+        return {
+          ...remaining,
+          ...subSchema
+        };
       }
       return subSchema;
     }
@@ -356,12 +298,12 @@
     if (formData === undefined) {
       return 0;
     }
-    for (var i = 0; i < options.length; i++) {
-      var option = options[i];
+    for (let i = 0; i < options.length; i++) {
+      const option = options[i];
       // If we have a discriminator field, then we will use this to make the determination
       if (discriminatorField && has__default["default"](option, [PROPERTIES_KEY, discriminatorField])) {
-        var value = get__default["default"](formData, discriminatorField);
-        var discriminator = get__default["default"](option, [PROPERTIES_KEY, discriminatorField], {});
+        const value = get__default["default"](formData, discriminatorField);
+        const discriminator = get__default["default"](option, [PROPERTIES_KEY, discriminatorField], {});
         if (validator.isValid(discriminator, value, rootSchema)) {
           return i;
         }
@@ -376,18 +318,18 @@
         //
         // Create an "anyOf" schema that requires at least one of the keys in the
         // "properties" object
-        var requiresAnyOf = {
-          anyOf: Object.keys(option[PROPERTIES_KEY]).map(function (key) {
-            return {
-              required: [key]
-            };
-          })
+        const requiresAnyOf = {
+          anyOf: Object.keys(option[PROPERTIES_KEY]).map(key => ({
+            required: [key]
+          }))
         };
-        var augmentedSchema = void 0;
+        let augmentedSchema;
         // If the "anyOf" keyword already exists, wrap the augmentation in an "allOf"
         if (option.anyOf) {
           // Create a shallow clone of the option
-          var shallowClone = _extends({}, (_objectDestructuringEmpty(option), option));
+          const {
+            ...shallowClone
+          } = option;
           if (!shallowClone.allOf) {
             shallowClone.allOf = [];
           } else {
@@ -434,12 +376,12 @@
    * @returns - The `discriminator.propertyName` if it exists in the schema, otherwise `undefined`
    */
   function getDiscriminatorFieldFromSchema(schema) {
-    var discriminator;
-    var maybeString = get__default["default"](schema, 'discriminator.propertyName', undefined);
+    let discriminator;
+    const maybeString = get__default["default"](schema, 'discriminator.propertyName', undefined);
     if (isString__default["default"](maybeString)) {
       discriminator = maybeString;
     } else if (maybeString !== undefined) {
-      console.warn("Expecting discriminator to be a string, got \"" + typeof maybeString + "\" instead");
+      console.warn(`Expecting discriminator to be a string, got "${typeof maybeString}" instead`);
     }
     return discriminator;
   }
@@ -485,20 +427,20 @@
    * @returns - The type of the schema
    */
   function getSchemaType(schema) {
-    var type = schema.type;
-    if (!type && schema["const"]) {
-      return guessType(schema["const"]);
+    let {
+      type
+    } = schema;
+    if (!type && schema.const) {
+      return guessType(schema.const);
     }
-    if (!type && schema["enum"]) {
+    if (!type && schema.enum) {
       return 'string';
     }
     if (!type && (schema.properties || schema.additionalProperties)) {
       return 'object';
     }
     if (Array.isArray(type) && type.length === 2 && type.includes('null')) {
-      type = type.find(function (type) {
-        return type !== 'null';
-      });
+      type = type.find(type => type !== 'null');
     }
     return type;
   }
@@ -512,9 +454,9 @@
    * @returns - The merged schema object
    */
   function mergeSchemas(obj1, obj2) {
-    var acc = Object.assign({}, obj1); // Prevent mutation of source object.
-    return Object.keys(obj2).reduce(function (acc, key) {
-      var left = obj1 ? obj1[key] : {},
+    const acc = Object.assign({}, obj1); // Prevent mutation of source object.
+    return Object.keys(obj2).reduce((acc, key) => {
+      const left = obj1 ? obj1[key] : {},
         right = obj2[key];
       if (obj1 && key in obj1 && isObject(right)) {
         acc[key] = mergeSchemas(left, right);
@@ -528,11 +470,6 @@
     }, acc);
   }
 
-  var _excluded$1 = ["if", "then", "else"],
-    _excluded2 = ["$ref"],
-    _excluded3 = ["allOf"],
-    _excluded4 = ["dependencies"],
-    _excluded5 = ["oneOf"];
   /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
    * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
    * potentially recursive resolution.
@@ -543,10 +480,7 @@
    * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
    * @returns - The schema having its conditions, additional properties, references and dependencies resolved
    */
-  function retrieveSchema(validator, schema, rootSchema, rawFormData) {
-    if (rootSchema === void 0) {
-      rootSchema = {};
-    }
+  function retrieveSchema(validator, schema, rootSchema = {}, rawFormData) {
     return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0];
   }
   /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
@@ -562,13 +496,15 @@
    * @returns - A list of schemas with the appropriate conditions resolved, possibly with all branches expanded
    */
   function resolveCondition(validator, schema, rootSchema, expandAllBranches, formData) {
-    var expression = schema["if"],
-      then = schema.then,
-      otherwise = schema["else"],
-      resolvedSchemaLessConditional = _objectWithoutPropertiesLoose(schema, _excluded$1);
-    var conditionValue = validator.isValid(expression, formData || {}, rootSchema);
-    var resolvedSchemas = [resolvedSchemaLessConditional];
-    var schemas = [];
+    const {
+      if: expression,
+      then,
+      else: otherwise,
+      ...resolvedSchemaLessConditional
+    } = schema;
+    const conditionValue = validator.isValid(expression, formData || {}, rootSchema);
+    let resolvedSchemas = [resolvedSchemaLessConditional];
+    let schemas = [];
     if (expandAllBranches) {
       if (then && typeof then !== 'boolean') {
         schemas = schemas.concat(retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches));
@@ -577,19 +513,15 @@
         schemas = schemas.concat(retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches));
       }
     } else {
-      var conditionalSchema = conditionValue ? then : otherwise;
+      const conditionalSchema = conditionValue ? then : otherwise;
       if (conditionalSchema && typeof conditionalSchema !== 'boolean') {
         schemas = schemas.concat(retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches));
       }
     }
     if (schemas.length) {
-      resolvedSchemas = schemas.map(function (s) {
-        return mergeSchemas(resolvedSchemaLessConditional, s);
-      });
+      resolvedSchemas = schemas.map(s => mergeSchemas(resolvedSchemaLessConditional, s));
     }
-    return resolvedSchemas.flatMap(function (s) {
-      return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches);
-    });
+    return resolvedSchemas.flatMap(s => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches));
   }
   /** Given a list of lists of allOf, anyOf or oneOf values, create a list of lists of all permutations of the values. The
    * `listOfLists` is expected to be all resolved values of the 1st...nth schemas within an `allOf`, `anyOf` or `oneOf`.
@@ -606,19 +538,13 @@
    * @returns - The list of all permutations of schemas for a set of `xxxOf`s
    */
   function getAllPermutationsOfXxxOf(listOfLists) {
-    var allPermutations = listOfLists.reduce(function (permutations, list) {
+    const allPermutations = listOfLists.reduce((permutations, list) => {
       // When there are more than one set of schemas for a row, duplicate the set of permutations and add in the values
       if (list.length > 1) {
-        return list.flatMap(function (element) {
-          return times__default["default"](permutations.length, function (i) {
-            return [].concat(permutations[i]).concat(element);
-          });
-        });
+        return list.flatMap(element => times__default["default"](permutations.length, i => [...permutations[i]].concat(element)));
       }
       // Otherwise just push in the single value into the current set of permutations
-      permutations.forEach(function (permutation) {
-        return permutation.push(list[0]);
-      });
+      permutations.forEach(permutation => permutation.push(list[0]));
       return permutations;
     }, [[]] // Start with an empty list
     );
@@ -642,21 +568,18 @@
       return resolveReference(validator, schema, rootSchema, expandAllBranches, formData);
     }
     if (DEPENDENCIES_KEY in schema) {
-      var resolvedSchemas = resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData);
-      return resolvedSchemas.flatMap(function (s) {
+      const resolvedSchemas = resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData);
+      return resolvedSchemas.flatMap(s => {
         return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches);
       });
     }
     if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
-      var allOfSchemaElements = schema.allOf.map(function (allOfSubschema) {
-        return retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches);
-      });
-      var allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
-      return allPermutations.map(function (permutation) {
-        return _extends({}, schema, {
-          allOf: permutation
-        });
-      });
+      const allOfSchemaElements = schema.allOf.map(allOfSubschema => retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches));
+      const allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
+      return allPermutations.map(permutation => ({
+        ...schema,
+        allOf: permutation
+      }));
     }
     // No $ref or dependencies or allOf attribute was found, returning the original schema.
     return [schema];
@@ -674,12 +597,48 @@
    */
   function resolveReference(validator, schema, rootSchema, expandAllBranches, formData) {
     // Drop the $ref property of the source schema.
-    var $ref = schema.$ref,
-      localSchema = _objectWithoutPropertiesLoose(schema, _excluded2);
+    const {
+      $ref,
+      ...localSchema
+    } = schema;
     // Retrieve the referenced schema definition.
-    var refSchema = findSchemaDefinition($ref, rootSchema);
+    const refSchema = findSchemaDefinition($ref, rootSchema);
     // Update referenced schema definition with local schema properties.
-    return retrieveSchemaInternal(validator, _extends({}, refSchema, localSchema), rootSchema, formData, expandAllBranches);
+    return retrieveSchemaInternal(validator, {
+      ...refSchema,
+      ...localSchema
+    }, rootSchema, formData, expandAllBranches);
+  }
+  /** Resolves all references within a schema's properties and array items.
+   *
+   * @param schema - The schema for which resolving all references is desired
+   * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @returns - given schema will all references resolved
+   */
+  function resolveAllReferences(schema, rootSchema) {
+    let resolvedSchema = schema;
+    // resolve top level ref
+    if (REF_KEY in resolvedSchema) {
+      const {
+        $ref,
+        ...localSchema
+      } = resolvedSchema;
+      // Retrieve the referenced schema definition.
+      const refSchema = findSchemaDefinition($ref, rootSchema);
+      resolvedSchema = {
+        ...refSchema,
+        ...localSchema
+      };
+    }
+    if (PROPERTIES_KEY in resolvedSchema) {
+      forEach__default["default"](resolvedSchema[PROPERTIES_KEY], (value, key) => {
+        resolvedSchema[PROPERTIES_KEY][key] = resolveAllReferences(value, rootSchema);
+      });
+    }
+    if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== 'boolean') {
+      resolvedSchema.items = resolveAllReferences(resolvedSchema.items, rootSchema);
+    }
+    return resolvedSchema;
   }
   /** Creates new 'properties' items for each key in the `formData`
    *
@@ -691,28 +650,34 @@
    */
   function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
     // Clone the schema so that we don't ruin the consumer's original
-    var schema = _extends({}, theSchema, {
-      properties: _extends({}, theSchema.properties)
-    });
+    const schema = {
+      ...theSchema,
+      properties: {
+        ...theSchema.properties
+      }
+    };
     // make sure formData is an object
-    var formData = aFormData && isObject(aFormData) ? aFormData : {};
-    Object.keys(formData).forEach(function (key) {
+    const formData = aFormData && isObject(aFormData) ? aFormData : {};
+    Object.keys(formData).forEach(key => {
       if (key in schema.properties) {
         // No need to stub, our schema already has the property
         return;
       }
-      var additionalProperties = {};
+      let additionalProperties = {};
       if (typeof schema.additionalProperties !== 'boolean') {
         if (REF_KEY in schema.additionalProperties) {
           additionalProperties = retrieveSchema(validator, {
             $ref: get__default["default"](schema.additionalProperties, [REF_KEY])
           }, rootSchema, formData);
         } else if ('type' in schema.additionalProperties) {
-          additionalProperties = _extends({}, schema.additionalProperties);
+          additionalProperties = {
+            ...schema.additionalProperties
+          };
         } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) {
-          additionalProperties = _extends({
-            type: 'object'
-          }, schema.additionalProperties);
+          additionalProperties = {
+            type: 'object',
+            ...schema.additionalProperties
+          };
         } else {
           additionalProperties = {
             type: guessType(get__default["default"](formData, [key]))
@@ -744,36 +709,35 @@
    * @returns - The schema(s) resulting from having its conditions, additional properties, references and dependencies
    *          resolved. Multiple schemas may be returned if `expandAllBranches` is true.
    */
-  function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches) {
-    if (expandAllBranches === void 0) {
-      expandAllBranches = false;
-    }
+  function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false) {
     if (!isObject(schema)) {
       return [{}];
     }
-    var resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, rawFormData);
-    return resolvedSchemas.flatMap(function (s) {
-      var resolvedSchema = s;
+    const resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, rawFormData);
+    return resolvedSchemas.flatMap(s => {
+      let resolvedSchema = s;
       if (IF_KEY in resolvedSchema) {
         return resolveCondition(validator, resolvedSchema, rootSchema, expandAllBranches, rawFormData);
       }
-      if (ALL_OF_KEY in schema) {
+      if (ALL_OF_KEY in resolvedSchema) {
+        // resolve allOf schemas
+        if (expandAllBranches) {
+          return [...resolvedSchema.allOf];
+        }
         try {
-          resolvedSchema = mergeAllOf__default["default"](s, {
+          resolvedSchema = mergeAllOf__default["default"](resolvedSchema, {
             deep: false
           });
         } catch (e) {
           console.warn('could not merge subschemas in allOf:\n', e);
-          var _resolvedSchema = resolvedSchema,
-            allOf = _resolvedSchema.allOf,
-            resolvedSchemaWithoutAllOf = _objectWithoutPropertiesLoose(_resolvedSchema, _excluded3);
-          if (expandAllBranches && allOf) {
-            return [resolvedSchemaWithoutAllOf].concat(allOf);
-          }
+          const {
+            allOf,
+            ...resolvedSchemaWithoutAllOf
+          } = resolvedSchema;
           return resolvedSchemaWithoutAllOf;
         }
       }
-      var hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
+      const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
       if (hasAdditionalProperties) {
         return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, rawFormData);
       }
@@ -793,29 +757,30 @@
    * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
    */
   function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranches, rawFormData) {
-    var anyOrOneOf;
-    if (Array.isArray(schema.oneOf)) {
-      anyOrOneOf = schema.oneOf;
-    } else if (Array.isArray(schema.anyOf)) {
-      anyOrOneOf = schema.anyOf;
+    let anyOrOneOf;
+    const {
+      oneOf,
+      anyOf,
+      ...remaining
+    } = schema;
+    if (Array.isArray(oneOf)) {
+      anyOrOneOf = oneOf;
+    } else if (Array.isArray(anyOf)) {
+      anyOrOneOf = anyOf;
     }
     if (anyOrOneOf) {
       // Ensure that during expand all branches we pass an object rather than undefined so that all options are interrogated
-      var formData = rawFormData === undefined && expandAllBranches ? {} : rawFormData;
-      var discriminator = getDiscriminatorFieldFromSchema(schema);
-      anyOrOneOf = anyOrOneOf.map(function (s) {
-        if (REF_KEY in s) {
-          // For this ref situation, don't expand all branches and just pick the first/only schema result
-          return resolveReference(validator, s, rootSchema, false, formData)[0];
-        }
-        return s;
+      const formData = rawFormData === undefined && expandAllBranches ? {} : rawFormData;
+      const discriminator = getDiscriminatorFieldFromSchema(schema);
+      anyOrOneOf = anyOrOneOf.map(s => {
+        return resolveAllReferences(s, rootSchema);
       });
       // Call this to trigger the set of isValid() calls that the schema parser will need
-      var option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator);
+      const option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator);
       if (expandAllBranches) {
-        return anyOrOneOf;
+        return anyOrOneOf.map(item => mergeSchemas(remaining, item));
       }
-      schema = anyOrOneOf[option];
+      schema = mergeSchemas(remaining, anyOrOneOf[option]);
     }
     return [schema];
   }
@@ -832,12 +797,12 @@
    */
   function resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData) {
     // Drop the dependencies from the source schema.
-    var dependencies = schema.dependencies,
-      remainingSchema = _objectWithoutPropertiesLoose(schema, _excluded4);
-    var resolvedSchemas = resolveAnyOrOneOfSchemas(validator, remainingSchema, rootSchema, expandAllBranches, formData);
-    return resolvedSchemas.flatMap(function (resolvedSchema) {
-      return processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData);
-    });
+    const {
+      dependencies,
+      ...remainingSchema
+    } = schema;
+    const resolvedSchemas = resolveAnyOrOneOfSchemas(validator, remainingSchema, rootSchema, expandAllBranches, formData);
+    return resolvedSchemas.flatMap(resolvedSchema => processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData));
   }
   /** Processes all the `dependencies` recursively into the list of `resolvedSchema`s as needed. Passes the
    * `expandAllBranches` flag down to the `withDependentSchema()` and the recursive `processDependencies()` helper calls.
@@ -852,35 +817,24 @@
    * @returns - The schema with the `dependencies` resolved into it
    */
   function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData) {
-    var schemas = [resolvedSchema];
+    let schemas = [resolvedSchema];
     // Process dependencies updating the local schema properties as appropriate.
-    var _loop = function _loop() {
+    for (const dependencyKey in dependencies) {
       // Skip this dependency if its trigger property is not present.
       if (!expandAllBranches && get__default["default"](formData, [dependencyKey]) === undefined) {
-        return "continue";
+        continue;
       }
       // Skip this dependency if it is not included in the schema (such as when dependencyKey is itself a hidden dependency.)
       if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
-        return "continue";
+        continue;
       }
-      var _splitKeyElementFromO = splitKeyElementFromObject(dependencyKey, dependencies),
-        remainingDependencies = _splitKeyElementFromO[0],
-        dependencyValue = _splitKeyElementFromO[1];
+      const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(dependencyKey, dependencies);
       if (Array.isArray(dependencyValue)) {
         schemas[0] = withDependentProperties(resolvedSchema, dependencyValue);
       } else if (isObject(dependencyValue)) {
         schemas = withDependentSchema(validator, resolvedSchema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, formData);
       }
-      return {
-        v: schemas.flatMap(function (schema) {
-          return processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, formData);
-        })
-      };
-    };
-    for (var dependencyKey in dependencies) {
-      var _ret = _loop();
-      if (_ret === "continue") continue;
-      if (typeof _ret === "object") return _ret.v;
+      return schemas.flatMap(schema => processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, formData));
     }
     return schemas;
   }
@@ -894,10 +848,11 @@
     if (!additionallyRequired) {
       return schema;
     }
-    var required = Array.isArray(schema.required) ? Array.from(new Set([].concat(schema.required, additionallyRequired))) : additionallyRequired;
-    return _extends({}, schema, {
+    const required = Array.isArray(schema.required) ? Array.from(new Set([...schema.required, ...additionallyRequired])) : additionallyRequired;
+    return {
+      ...schema,
       required: required
-    });
+    };
   }
   /** Merges a dependent schema into the `schema` dealing with oneOfs and references. Passes the `expandAllBranches` flag
    * down to the `retrieveSchemaInternal()`, `resolveReference()` and `withExactlyOneSubschema()` helper calls.
@@ -913,26 +868,26 @@
    * @returns - The list of schemas with the dependent schema resolved into them
    */
   function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, formData) {
-    var dependentSchemas = retrieveSchemaInternal(validator, dependencyValue, rootSchema, formData, expandAllBranches);
-    return dependentSchemas.flatMap(function (dependent) {
-      var oneOf = dependent.oneOf,
-        dependentSchema = _objectWithoutPropertiesLoose(dependent, _excluded5);
+    const dependentSchemas = retrieveSchemaInternal(validator, dependencyValue, rootSchema, formData, expandAllBranches);
+    return dependentSchemas.flatMap(dependent => {
+      const {
+        oneOf,
+        ...dependentSchema
+      } = dependent;
       schema = mergeSchemas(schema, dependentSchema);
       // Since it does not contain oneOf, we return the original schema.
       if (oneOf === undefined) {
         return schema;
       }
       // Resolve $refs inside oneOf.
-      var resolvedOneOfs = oneOf.map(function (subschema) {
+      const resolvedOneOfs = oneOf.map(subschema => {
         if (typeof subschema === 'boolean' || !(REF_KEY in subschema)) {
           return [subschema];
         }
         return resolveReference(validator, subschema, rootSchema, expandAllBranches, formData);
       });
-      var allPermutations = getAllPermutationsOfXxxOf(resolvedOneOfs);
-      return allPermutations.flatMap(function (resolvedOneOf) {
-        return withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, expandAllBranches, formData);
-      });
+      const allPermutations = getAllPermutationsOfXxxOf(resolvedOneOfs);
+      return allPermutations.flatMap(resolvedOneOf => withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, expandAllBranches, formData));
     });
   }
   /** Returns a list of `schema`s with the best choice from the `oneOf` options merged into it. If `expandAllBranches` is
@@ -950,16 +905,19 @@
    * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
    */
   function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, formData) {
-    var validSubschemas = oneOf.filter(function (subschema) {
+    const validSubschemas = oneOf.filter(subschema => {
       if (typeof subschema === 'boolean' || !subschema || !subschema.properties) {
         return false;
       }
-      var conditionPropertySchema = subschema.properties[dependencyKey];
+      const {
+        [dependencyKey]: conditionPropertySchema
+      } = subschema.properties;
       if (conditionPropertySchema) {
-        var _properties;
-        var conditionSchema = {
+        const conditionSchema = {
           type: 'object',
-          properties: (_properties = {}, _properties[dependencyKey] = conditionPropertySchema, _properties)
+          properties: {
+            [dependencyKey]: conditionPropertySchema
+          }
         };
         return validator.isValid(conditionSchema, formData, rootSchema) || expandAllBranches;
       }
@@ -969,24 +927,22 @@
       console.warn("ignoring oneOf in dependencies because there isn't exactly one subschema that is valid");
       return [schema];
     }
-    return validSubschemas.flatMap(function (s) {
-      var subschema = s;
-      var _splitKeyElementFromO2 = splitKeyElementFromObject(dependencyKey, subschema.properties),
-        dependentSubschema = _splitKeyElementFromO2[0];
-      var dependentSchema = _extends({}, subschema, {
+    return validSubschemas.flatMap(s => {
+      const subschema = s;
+      const [dependentSubschema] = splitKeyElementFromObject(dependencyKey, subschema.properties);
+      const dependentSchema = {
+        ...subschema,
         properties: dependentSubschema
-      });
-      var schemas = retrieveSchemaInternal(validator, dependentSchema, rootSchema, formData, expandAllBranches);
-      return schemas.map(function (s) {
-        return mergeSchemas(schema, s);
-      });
+      };
+      const schemas = retrieveSchemaInternal(validator, dependentSchema, rootSchema, formData, expandAllBranches);
+      return schemas.map(s => mergeSchemas(schema, s));
     });
   }
 
   /** A junk option used to determine when the getFirstMatchingOption call really matches an option rather than returning
    * the first item
    */
-  var JUNK_OPTION = {
+  const JUNK_OPTION = {
     type: 'object',
     $id: JUNK_OPTION_ID,
     properties: {
@@ -1015,39 +971,38 @@
    * @param formData - The form data associated with the schema, used to calculate the score
    * @returns - The score a schema against the formData
    */
-  function calculateIndexScore(validator, rootSchema, schema, formData) {
-    if (formData === void 0) {
-      formData = {};
-    }
-    var totalScore = 0;
+  function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
+    let totalScore = 0;
     if (schema) {
       if (isObject__default["default"](schema.properties)) {
-        totalScore += reduce__default["default"](schema.properties, function (score, value, key) {
-          var formValue = get__default["default"](formData, key);
+        totalScore += reduce__default["default"](schema.properties, (score, value, key) => {
+          const formValue = get__default["default"](formData, key);
           if (typeof value === 'boolean') {
             return score;
           }
           if (has__default["default"](value, REF_KEY)) {
-            var newSchema = retrieveSchema(validator, value, rootSchema, formValue);
+            const newSchema = retrieveSchema(validator, value, rootSchema, formValue);
             return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {});
           }
-          if (has__default["default"](value, ONE_OF_KEY) && formValue) {
-            return score + getClosestMatchingOption(validator, rootSchema, formValue, get__default["default"](value, ONE_OF_KEY));
+          if ((has__default["default"](value, ONE_OF_KEY) || has__default["default"](value, ANY_OF_KEY)) && formValue) {
+            const key = has__default["default"](value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            const discriminator = getDiscriminatorFieldFromSchema(value);
+            return score + getClosestMatchingOption(validator, rootSchema, formValue, get__default["default"](value, key), -1, discriminator);
           }
           if (value.type === 'object') {
             return score + calculateIndexScore(validator, rootSchema, value, formValue || {});
           }
           if (value.type === guessType(formValue)) {
             // If the types match, then we bump the score by one
-            var newScore = score + 1;
-            if (value["default"]) {
+            let newScore = score + 1;
+            if (value.default) {
               // If the schema contains a readonly default value score the value that matches the default higher and
               // any non-matching value lower
-              newScore += formValue === value["default"] ? 1 : -1;
-            } else if (value["const"]) {
+              newScore += formValue === value.default ? 1 : -1;
+            } else if (value.const) {
               // If the schema contains a const value score the value that matches the default higher and
               // any non-matching value lower
-              newScore += formValue === value["const"] ? 1 : -1;
+              newScore += formValue === value.const ? 1 : -1;
             }
             // TODO eventually, deal with enums/arrays
             return newScore;
@@ -1082,14 +1037,15 @@
    *          determine which option is selected
    * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
    */
-  function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption, discriminatorField) {
-    if (selectedOption === void 0) {
-      selectedOption = -1;
-    }
+  function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField) {
+    // First resolve any refs in the options
+    const resolvedOptions = options.map(option => {
+      return resolveAllReferences(option, rootSchema);
+    });
     // Reduce the array of options down to a list of the indexes that are considered matching options
-    var allValidIndexes = options.reduce(function (validList, option, index) {
-      var testOptions = [JUNK_OPTION, option];
-      var match = getFirstMatchingOption(validator, formData, testOptions, rootSchema, discriminatorField);
+    const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
+      const testOptions = [JUNK_OPTION, option];
+      const match = getFirstMatchingOption(validator, formData, testOptions, rootSchema, discriminatorField);
       // The match is the real option, so add its index to list of valid indexes
       if (match === 1) {
         validList.push(index);
@@ -1102,32 +1058,30 @@
     }
     if (!allValidIndexes.length) {
       // No indexes were valid, so we'll score all the options, add all the indexes
-      times__default["default"](options.length, function (i) {
-        return allValidIndexes.push(i);
-      });
+      times__default["default"](resolvedOptions.length, i => allValidIndexes.push(i));
     }
-    var scoreCount = new Set();
+    const scoreCount = new Set();
     // Score all the options in the list of valid indexes and return the index with the best score
-    var _allValidIndexes$redu = allValidIndexes.reduce(function (scoreData, index) {
-        var bestScore = scoreData.bestScore;
-        var option = options[index];
-        if (has__default["default"](option, REF_KEY)) {
-          option = retrieveSchema(validator, option, rootSchema, formData);
-        }
-        var score = calculateIndexScore(validator, rootSchema, option, formData);
-        scoreCount.add(score);
-        if (score > bestScore) {
-          return {
-            bestIndex: index,
-            bestScore: score
-          };
-        }
-        return scoreData;
-      }, {
-        bestIndex: selectedOption,
-        bestScore: 0
-      }),
-      bestIndex = _allValidIndexes$redu.bestIndex;
+    const {
+      bestIndex
+    } = allValidIndexes.reduce((scoreData, index) => {
+      const {
+        bestScore
+      } = scoreData;
+      const option = resolvedOptions[index];
+      const score = calculateIndexScore(validator, rootSchema, option, formData);
+      scoreCount.add(score);
+      if (score > bestScore) {
+        return {
+          bestIndex: index,
+          bestScore: score
+        };
+      }
+      return scoreData;
+    }, {
+      bestIndex: selectedOption,
+      bestScore: 0
+    });
     // if all scores are the same go with selectedOption
     if (scoreCount.size === 1 && selectedOption >= 0) {
       return selectedOption;
@@ -1142,9 +1096,7 @@
    * @returns - True if there are fixed items in the schema, false otherwise
    */
   function isFixedItems(schema) {
-    return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every(function (item) {
-      return isObject(item);
-    });
+    return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every(item => isObject(item));
   }
 
   /** Merges the `defaults` object of type `T` into the `formData` of type `T`
@@ -1163,13 +1115,10 @@
    * @param [mergeExtraArrayDefaults=false] - If true, any additional default array entries are appended onto the formData
    * @returns - The resulting merged form data with defaults
    */
-  function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults) {
-    if (mergeExtraArrayDefaults === void 0) {
-      mergeExtraArrayDefaults = false;
-    }
+  function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false) {
     if (Array.isArray(formData)) {
-      var defaultsArray = Array.isArray(defaults) ? defaults : [];
-      var mapped = formData.map(function (value, idx) {
+      const defaultsArray = Array.isArray(defaults) ? defaults : [];
+      const mapped = formData.map((value, idx) => {
         if (defaultsArray[idx]) {
           return mergeDefaultsWithFormData(defaultsArray[idx], value, mergeExtraArrayDefaults);
         }
@@ -1177,13 +1126,13 @@
       });
       // Merge any extra defaults when mergeExtraArrayDefaults is true
       if (mergeExtraArrayDefaults && mapped.length < defaultsArray.length) {
-        mapped.push.apply(mapped, defaultsArray.slice(mapped.length));
+        mapped.push(...defaultsArray.slice(mapped.length));
       }
       return mapped;
     }
     if (isObject(formData)) {
-      var acc = Object.assign({}, defaults); // Prevent mutation of source object.
-      return Object.keys(formData).reduce(function (acc, key) {
+      const acc = Object.assign({}, defaults); // Prevent mutation of source object.
+      return Object.keys(formData).reduce((acc, key) => {
         acc[key] = mergeDefaultsWithFormData(defaults ? get__default["default"](defaults, key) : {}, get__default["default"](formData, key), mergeExtraArrayDefaults);
         return acc;
       }, acc);
@@ -1200,19 +1149,16 @@
    *          NOTE: Uses shallow comparison for the duplicate checking.
    * @returns - A new object that is the merge of the two given objects
    */
-  function mergeObjects(obj1, obj2, concatArrays) {
-    if (concatArrays === void 0) {
-      concatArrays = false;
-    }
-    return Object.keys(obj2).reduce(function (acc, key) {
-      var left = obj1 ? obj1[key] : {},
+  function mergeObjects(obj1, obj2, concatArrays = false) {
+    return Object.keys(obj2).reduce((acc, key) => {
+      const left = obj1 ? obj1[key] : {},
         right = obj2[key];
       if (obj1 && key in obj1 && isObject(right)) {
         acc[key] = mergeObjects(left, right, concatArrays);
       } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
-        var toMerge = right;
+        let toMerge = right;
         if (concatArrays === 'preventDuplicates') {
-          toMerge = right.reduce(function (result, value) {
+          toMerge = right.reduce((result, value) => {
             if (!left.includes(value)) {
               result.push(value);
             }
@@ -1234,7 +1180,7 @@
    * @returns - True if the `schema` has a single constant value, false otherwise
    */
   function isConstant(schema) {
-    return Array.isArray(schema["enum"]) && schema["enum"].length === 1 || CONST_KEY in schema;
+    return Array.isArray(schema.enum) && schema.enum.length === 1 || CONST_KEY in schema;
   }
 
   /** Checks to see if the `schema` combination represents a select
@@ -1244,19 +1190,14 @@
    * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
    * @returns - True if schema contains a select, otherwise false
    */
-  function isSelect(validator, theSchema, rootSchema) {
-    if (rootSchema === void 0) {
-      rootSchema = {};
-    }
-    var schema = retrieveSchema(validator, theSchema, rootSchema, undefined);
-    var altSchemas = schema.oneOf || schema.anyOf;
-    if (Array.isArray(schema["enum"])) {
+  function isSelect(validator, theSchema, rootSchema = {}) {
+    const schema = retrieveSchema(validator, theSchema, rootSchema, undefined);
+    const altSchemas = schema.oneOf || schema.anyOf;
+    if (Array.isArray(schema.enum)) {
       return true;
     }
     if (Array.isArray(altSchemas)) {
-      return altSchemas.every(function (altSchemas) {
-        return typeof altSchemas !== 'boolean' && isConstant(altSchemas);
-      });
+      return altSchemas.every(altSchemas => typeof altSchemas !== 'boolean' && isConstant(altSchemas));
     }
     return false;
   }
@@ -1298,16 +1239,10 @@
    * @param [idx=-1] - Index, if non-negative, will be used to return the idx-th element in a `schema.items` array
    * @returns - The best fit schema object from the `schema` given the `additionalItems` and `idx` modifiers
    */
-  function getInnerSchemaForArrayItem(schema, additionalItems, idx) {
-    if (additionalItems === void 0) {
-      additionalItems = AdditionalItemsHandling.Ignore;
-    }
-    if (idx === void 0) {
-      idx = -1;
-    }
+  function getInnerSchemaForArrayItem(schema, additionalItems = AdditionalItemsHandling.Ignore, idx = -1) {
     if (idx >= 0) {
       if (Array.isArray(schema.items) && idx < schema.items.length) {
-        var item = schema.items[idx];
+        const item = schema.items[idx];
         if (typeof item !== 'boolean') {
           return item;
         }
@@ -1339,23 +1274,17 @@
    * @param experimental_defaultFormStateBehavior - Optional configuration object, if provided, allows users to override
    *        default form state behavior
    */
-  function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields, experimental_defaultFormStateBehavior) {
-    if (requiredFields === void 0) {
-      requiredFields = [];
-    }
-    if (experimental_defaultFormStateBehavior === void 0) {
-      experimental_defaultFormStateBehavior = {};
-    }
-    var _experimental_default = experimental_defaultFormStateBehavior,
-      _experimental_default2 = _experimental_default.emptyObjectFields,
-      emptyObjectFields = _experimental_default2 === void 0 ? 'populateAllDefaults' : _experimental_default2;
+  function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}) {
+    const {
+      emptyObjectFields = 'populateAllDefaults'
+    } = experimental_defaultFormStateBehavior;
     if (includeUndefinedValues) {
       obj[key] = computedDefault;
     } else if (emptyObjectFields !== 'skipDefaults') {
       if (isObject(computedDefault)) {
         // If isParentRequired is undefined, then we are at the root level of the schema so defer to the requiredness of
         // the field key itself in the `requiredField` list
-        var isSelfOrParentRequired = isParentRequired === undefined ? requiredFields.includes(key) : isParentRequired;
+        const isSelfOrParentRequired = isParentRequired === undefined ? requiredFields.includes(key) : isParentRequired;
         // Store computedDefault if it's a non-empty object(e.g. not {}) and satisfies certain conditions
         // Condition 1: If computedDefault is not empty or if the key is a required field
         // Condition 2: If the parent object is required or emptyObjectFields is not 'populateRequiredDefaults'
@@ -1388,94 +1317,98 @@
    * @param [props.required] - Optional flag, if true, indicates this schema was required in the parent schema.
    * @returns - The resulting `formData` with all the defaults provided
    */
-  function computeDefaults(validator, rawSchema, _temp) {
-    var _ref = _temp === void 0 ? {} : _temp,
-      parentDefaults = _ref.parentDefaults,
-      rawFormData = _ref.rawFormData,
-      _ref$rootSchema = _ref.rootSchema,
-      rootSchema = _ref$rootSchema === void 0 ? {} : _ref$rootSchema,
-      _ref$includeUndefined = _ref.includeUndefinedValues,
-      includeUndefinedValues = _ref$includeUndefined === void 0 ? false : _ref$includeUndefined,
-      _ref$_recurseList = _ref._recurseList,
-      _recurseList = _ref$_recurseList === void 0 ? [] : _ref$_recurseList,
-      _ref$experimental_def = _ref.experimental_defaultFormStateBehavior,
-      experimental_defaultFormStateBehavior = _ref$experimental_def === void 0 ? undefined : _ref$experimental_def,
-      required = _ref.required;
-    var formData = isObject(rawFormData) ? rawFormData : {};
-    var schema = isObject(rawSchema) ? rawSchema : {};
+  function computeDefaults(validator, rawSchema, {
+    parentDefaults,
+    rawFormData,
+    rootSchema = {},
+    includeUndefinedValues = false,
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = undefined,
+    required
+  } = {}) {
+    const formData = isObject(rawFormData) ? rawFormData : {};
+    const schema = isObject(rawSchema) ? rawSchema : {};
     // Compute the defaults recursively: give highest priority to deepest nodes.
-    var defaults = parentDefaults;
+    let defaults = parentDefaults;
     // If we get a new schema, then we need to recompute defaults again for the new schema found.
-    var schemaToCompute = null;
-    var updatedRecurseList = _recurseList;
-    if (isObject(defaults) && isObject(schema["default"])) {
+    let schemaToCompute = null;
+    let updatedRecurseList = _recurseList;
+    if (isObject(defaults) && isObject(schema.default)) {
       // For object defaults, only override parent defaults that are defined in
       // schema.default.
-      defaults = mergeObjects(defaults, schema["default"]);
+      defaults = mergeObjects(defaults, schema.default);
     } else if (DEFAULT_KEY in schema) {
-      defaults = schema["default"];
+      defaults = schema.default;
     } else if (REF_KEY in schema) {
-      var refName = schema[REF_KEY];
+      const refName = schema[REF_KEY];
       // Use referenced schema defaults for this node.
       if (!_recurseList.includes(refName)) {
         updatedRecurseList = _recurseList.concat(refName);
         schemaToCompute = findSchemaDefinition(refName, rootSchema);
       }
     } else if (DEPENDENCIES_KEY in schema) {
-      var resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, formData);
+      const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, formData);
       schemaToCompute = resolvedSchema[0]; // pick the first element from resolve dependencies
     } else if (isFixedItems(schema)) {
-      defaults = schema.items.map(function (itemSchema, idx) {
-        return computeDefaults(validator, itemSchema, {
-          rootSchema: rootSchema,
-          includeUndefinedValues: includeUndefinedValues,
-          _recurseList: _recurseList,
-          experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
-          parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined,
-          rawFormData: formData,
-          required: required
-        });
-      });
+      defaults = schema.items.map((itemSchema, idx) => computeDefaults(validator, itemSchema, {
+        rootSchema,
+        includeUndefinedValues,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined,
+        rawFormData: formData,
+        required
+      }));
     } else if (ONE_OF_KEY in schema) {
-      if (schema.oneOf.length === 0) {
+      const {
+        oneOf,
+        ...remaining
+      } = schema;
+      if (oneOf.length === 0) {
         return undefined;
       }
-      var discriminator = getDiscriminatorFieldFromSchema(schema);
-      schemaToCompute = schema.oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, schema.oneOf, 0, discriminator)];
+      const discriminator = getDiscriminatorFieldFromSchema(schema);
+      schemaToCompute = oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, oneOf, 0, discriminator)];
+      schemaToCompute = mergeSchemas(remaining, schemaToCompute);
     } else if (ANY_OF_KEY in schema) {
-      if (schema.anyOf.length === 0) {
+      const {
+        anyOf,
+        ...remaining
+      } = schema;
+      if (anyOf.length === 0) {
         return undefined;
       }
-      var _discriminator = getDiscriminatorFieldFromSchema(schema);
-      schemaToCompute = schema.anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, schema.anyOf, 0, _discriminator)];
+      const discriminator = getDiscriminatorFieldFromSchema(schema);
+      schemaToCompute = anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, anyOf, 0, discriminator)];
+      schemaToCompute = mergeSchemas(remaining, schemaToCompute);
     }
     if (schemaToCompute) {
       return computeDefaults(validator, schemaToCompute, {
-        rootSchema: rootSchema,
-        includeUndefinedValues: includeUndefinedValues,
+        rootSchema,
+        includeUndefinedValues,
         _recurseList: updatedRecurseList,
-        experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+        experimental_defaultFormStateBehavior,
         parentDefaults: defaults,
         rawFormData: formData,
-        required: required
+        required
       });
     }
     // No defaults defined for this node, fallback to generic typed ones.
     if (defaults === undefined) {
-      defaults = schema["default"];
+      defaults = schema.default;
     }
     switch (getSchemaType(schema)) {
       // We need to recurse for object schema inner default values.
       case 'object':
         {
-          var objectDefaults = Object.keys(schema.properties || {}).reduce(function (acc, key) {
+          const objectDefaults = Object.keys(schema.properties || {}).reduce((acc, key) => {
             var _schema$required;
             // Compute the defaults for this node, with the parent defaults we might
             // have from a previous run: defaults[key].
-            var computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), {
-              rootSchema: rootSchema,
-              _recurseList: _recurseList,
-              experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+            const computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), {
+              rootSchema,
+              _recurseList,
+              experimental_defaultFormStateBehavior,
               includeUndefinedValues: includeUndefinedValues === true,
               parentDefaults: get__default["default"](defaults, [key]),
               rawFormData: get__default["default"](formData, [key]),
@@ -1486,31 +1419,25 @@
           }, {});
           if (schema.additionalProperties) {
             // as per spec additionalProperties may be either schema or boolean
-            var additionalPropertiesSchema = isObject(schema.additionalProperties) ? schema.additionalProperties : {};
-            var keys = new Set();
+            const additionalPropertiesSchema = isObject(schema.additionalProperties) ? schema.additionalProperties : {};
+            const keys = new Set();
             if (isObject(defaults)) {
-              Object.keys(defaults).filter(function (key) {
-                return !schema.properties || !schema.properties[key];
-              }).forEach(function (key) {
-                return keys.add(key);
-              });
+              Object.keys(defaults).filter(key => !schema.properties || !schema.properties[key]).forEach(key => keys.add(key));
             }
-            var formDataRequired;
+            let formDataRequired;
             if (isObject(formData)) {
               formDataRequired = [];
-              Object.keys(formData).filter(function (key) {
-                return !schema.properties || !schema.properties[key];
-              }).forEach(function (key) {
+              Object.keys(formData).filter(key => !schema.properties || !schema.properties[key]).forEach(key => {
                 keys.add(key);
                 formDataRequired.push(key);
               });
             }
-            keys.forEach(function (key) {
+            keys.forEach(key => {
               var _schema$required2;
-              var computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
-                rootSchema: rootSchema,
-                _recurseList: _recurseList,
-                experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+              const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
+                rootSchema,
+                _recurseList,
+                experimental_defaultFormStateBehavior,
                 includeUndefinedValues: includeUndefinedValues === true,
                 parentDefaults: get__default["default"](defaults, [key]),
                 rawFormData: get__default["default"](formData, [key]),
@@ -1524,54 +1451,54 @@
         }
       case 'array':
         {
-          var _experimental_default3;
+          var _experimental_default;
           // Inject defaults into existing array defaults
           if (Array.isArray(defaults)) {
-            defaults = defaults.map(function (item, idx) {
-              var schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
+            defaults = defaults.map((item, idx) => {
+              const schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
               return computeDefaults(validator, schemaItem, {
-                rootSchema: rootSchema,
-                _recurseList: _recurseList,
-                experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+                rootSchema,
+                _recurseList,
+                experimental_defaultFormStateBehavior,
                 parentDefaults: item,
-                required: required
+                required
               });
             });
           }
           // Deeply inject defaults into already existing form data
           if (Array.isArray(rawFormData)) {
-            var schemaItem = getInnerSchemaForArrayItem(schema);
-            defaults = rawFormData.map(function (item, idx) {
+            const schemaItem = getInnerSchemaForArrayItem(schema);
+            defaults = rawFormData.map((item, idx) => {
               return computeDefaults(validator, schemaItem, {
-                rootSchema: rootSchema,
-                _recurseList: _recurseList,
-                experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+                rootSchema,
+                _recurseList,
+                experimental_defaultFormStateBehavior,
                 rawFormData: item,
                 parentDefaults: get__default["default"](defaults, [idx]),
-                required: required
+                required
               });
             });
           }
-          var ignoreMinItemsFlagSet = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : (_experimental_default3 = experimental_defaultFormStateBehavior.arrayMinItems) === null || _experimental_default3 === void 0 ? void 0 : _experimental_default3.populate) === 'requiredOnly';
+          const ignoreMinItemsFlagSet = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : (_experimental_default = experimental_defaultFormStateBehavior.arrayMinItems) === null || _experimental_default === void 0 ? void 0 : _experimental_default.populate) === 'requiredOnly';
           if (ignoreMinItemsFlagSet && !required) {
             // If no form data exists or defaults are set leave the field empty/non-existent, otherwise
             // return form data/defaults
             return defaults ? defaults : undefined;
           }
-          var defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+          const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
           if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
             return defaults ? defaults : [];
           }
-          var defaultEntries = defaults || [];
-          var fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
-          var fillerDefault = fillerSchema["default"];
+          const defaultEntries = defaults || [];
+          const fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
+          const fillerDefault = fillerSchema.default;
           // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
-          var fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, {
+          const fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, {
             parentDefaults: fillerDefault,
-            rootSchema: rootSchema,
-            _recurseList: _recurseList,
-            experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
-            required: required
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
+            required
           }));
           // then fill up the rest with either the item default or empty, up to minItems
           return defaultEntries.concat(fillerEntries);
@@ -1592,26 +1519,24 @@
    * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
    * @returns - The resulting `formData` with all the defaults provided
    */
-  function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues, experimental_defaultFormStateBehavior) {
-    if (includeUndefinedValues === void 0) {
-      includeUndefinedValues = false;
-    }
+  function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior) {
     if (!isObject(theSchema)) {
       throw new Error('Invalid schema: ' + theSchema);
     }
-    var schema = retrieveSchema(validator, theSchema, rootSchema, formData);
-    var defaults = computeDefaults(validator, schema, {
-      rootSchema: rootSchema,
-      includeUndefinedValues: includeUndefinedValues,
-      experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+    const schema = retrieveSchema(validator, theSchema, rootSchema, formData);
+    const defaults = computeDefaults(validator, schema, {
+      rootSchema,
+      includeUndefinedValues,
+      experimental_defaultFormStateBehavior,
       rawFormData: formData
     });
     if (formData === undefined || formData === null || typeof formData === 'number' && isNaN(formData)) {
       // No form data? Use schema defaults.
       return defaults;
     }
-    var _ref2 = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.arrayMinItems) || {},
-      mergeExtraDefaults = _ref2.mergeExtraDefaults;
+    const {
+      mergeExtraDefaults
+    } = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.arrayMinItems) || {};
     if (isObject(formData)) {
       return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults);
     }
@@ -1626,10 +1551,7 @@
    * @param uiSchema - The UI Schema from which to detect if it is customized
    * @returns - True if the `uiSchema` describes a custom widget, false otherwise
    */
-  function isCustomWidget(uiSchema) {
-    if (uiSchema === void 0) {
-      uiSchema = {};
-    }
+  function isCustomWidget(uiSchema = {}) {
     return (
       // TODO: Remove the `&& uiSchema['ui:widget'] !== 'hidden'` once we support hidden widgets for arrays.
       // https://rjsf-team.github.io/react-jsonschema-form/docs/usage/widgets/#hidden-widgets
@@ -1645,15 +1567,12 @@
    * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
    * @returns - True if schema/uiSchema contains an array of files, otherwise false
    */
-  function isFilesArray(validator, schema, uiSchema, rootSchema) {
-    if (uiSchema === void 0) {
-      uiSchema = {};
-    }
+  function isFilesArray(validator, schema, uiSchema = {}, rootSchema) {
     if (uiSchema[UI_WIDGET_KEY] === 'files') {
       return true;
     }
     if (schema.items) {
-      var itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
+      const itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
       return itemsSchema.type === 'string' && itemsSchema.format === 'data-url';
     }
     return false;
@@ -1669,15 +1588,13 @@
    * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
    * @returns - True if the label should be displayed or false if it should not
    */
-  function getDisplayLabel(validator, schema, uiSchema, rootSchema, globalOptions) {
-    if (uiSchema === void 0) {
-      uiSchema = {};
-    }
-    var uiOptions = getUiOptions(uiSchema, globalOptions);
-    var _uiOptions$label = uiOptions.label,
-      label = _uiOptions$label === void 0 ? true : _uiOptions$label;
-    var displayLabel = !!label;
-    var schemaType = getSchemaType(schema);
+  function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOptions) {
+    const uiOptions = getUiOptions(uiSchema, globalOptions);
+    const {
+      label = true
+    } = uiOptions;
+    let displayLabel = !!label;
+    const schemaType = getSchemaType(schema);
     if (schemaType === 'array') {
       displayLabel = isMultiSelect(validator, schema, rootSchema) || isFilesArray(validator, schema, uiSchema, rootSchema) || isCustomWidget(uiSchema);
     }
@@ -1709,21 +1626,23 @@
     if (!additionalErrorSchema) {
       return validationData;
     }
-    var oldErrors = validationData.errors,
-      oldErrorSchema = validationData.errorSchema;
-    var errors = validator.toErrorList(additionalErrorSchema);
-    var errorSchema = additionalErrorSchema;
+    const {
+      errors: oldErrors,
+      errorSchema: oldErrorSchema
+    } = validationData;
+    let errors = validator.toErrorList(additionalErrorSchema);
+    let errorSchema = additionalErrorSchema;
     if (!isEmpty__default["default"](oldErrorSchema)) {
       errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
-      errors = [].concat(oldErrors).concat(errors);
+      errors = [...oldErrors].concat(errors);
     }
     return {
-      errorSchema: errorSchema,
-      errors: errors
+      errorSchema,
+      errors
     };
   }
 
-  var NO_VALUE = /*#__PURE__*/Symbol('no Value');
+  const NO_VALUE = /*#__PURE__*/Symbol('no Value');
   /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the new
    * schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the nature
    * of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the old schema
@@ -1771,31 +1690,28 @@
    * @returns - The new form data, with all the fields uniquely associated with the old schema set
    *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
    */
-  function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data) {
-    if (data === void 0) {
-      data = {};
-    }
+  function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}) {
     // By default, we will clear the form data
-    var newFormData;
+    let newFormData;
     // If the new schema is of type object and that object contains a list of properties
     if (has__default["default"](newSchema, PROPERTIES_KEY)) {
       // Create an object containing root-level keys in the old schema, setting each key to undefined to remove the data
-      var removeOldSchemaData = {};
+      const removeOldSchemaData = {};
       if (has__default["default"](oldSchema, PROPERTIES_KEY)) {
-        var properties = get__default["default"](oldSchema, PROPERTIES_KEY, {});
-        Object.keys(properties).forEach(function (key) {
+        const properties = get__default["default"](oldSchema, PROPERTIES_KEY, {});
+        Object.keys(properties).forEach(key => {
           if (has__default["default"](data, key)) {
             removeOldSchemaData[key] = undefined;
           }
         });
       }
-      var keys = Object.keys(get__default["default"](newSchema, PROPERTIES_KEY, {}));
+      const keys = Object.keys(get__default["default"](newSchema, PROPERTIES_KEY, {}));
       // Create a place to store nested data that will be a side-effect of the filter
-      var nestedData = {};
-      keys.forEach(function (key) {
-        var formValue = get__default["default"](data, key);
-        var oldKeyedSchema = get__default["default"](oldSchema, [PROPERTIES_KEY, key], {});
-        var newKeyedSchema = get__default["default"](newSchema, [PROPERTIES_KEY, key], {});
+      const nestedData = {};
+      keys.forEach(key => {
+        const formValue = get__default["default"](data, key);
+        let oldKeyedSchema = get__default["default"](oldSchema, [PROPERTIES_KEY, key], {});
+        let newKeyedSchema = get__default["default"](newSchema, [PROPERTIES_KEY, key], {});
         // Resolve the refs if they exist
         if (has__default["default"](oldKeyedSchema, REF_KEY)) {
           oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
@@ -1804,8 +1720,8 @@
           newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
         }
         // Now get types and see if they are the same
-        var oldSchemaTypeForKey = get__default["default"](oldKeyedSchema, 'type');
-        var newSchemaTypeForKey = get__default["default"](newKeyedSchema, 'type');
+        const oldSchemaTypeForKey = get__default["default"](oldKeyedSchema, 'type');
+        const newSchemaTypeForKey = get__default["default"](newKeyedSchema, 'type');
         // Check if the old option has the same key with the same type
         if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
           if (has__default["default"](removeOldSchemaData, key)) {
@@ -1815,7 +1731,7 @@
           // If it is an object, we'll recurse and store the resulting sanitized data for the key
           if (newSchemaTypeForKey === 'object' || newSchemaTypeForKey === 'array' && Array.isArray(formValue)) {
             // SIDE-EFFECT: process the new schema type of object recursively to save iterations
-            var itemData = sanitizeDataForNewSchema(validator, rootSchema, newKeyedSchema, oldKeyedSchema, formValue);
+            const itemData = sanitizeDataForNewSchema(validator, rootSchema, newKeyedSchema, oldKeyedSchema, formValue);
             if (itemData !== undefined || newSchemaTypeForKey === 'array') {
               // only put undefined values for the array type and not the object type
               nestedData[key] = itemData;
@@ -1824,8 +1740,8 @@
             // Ok, the non-object types match, let's make sure that a default or a const of a different value is replaced
             // with the new default or const. This allows the case where two schemas differ that only by the default/const
             // value to be properly selected
-            var newOptionDefault = get__default["default"](newKeyedSchema, 'default', NO_VALUE);
-            var oldOptionDefault = get__default["default"](oldKeyedSchema, 'default', NO_VALUE);
+            const newOptionDefault = get__default["default"](newKeyedSchema, 'default', NO_VALUE);
+            const oldOptionDefault = get__default["default"](oldKeyedSchema, 'default', NO_VALUE);
             if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
               if (oldOptionDefault === formValue) {
                 // If the old default matches the formValue, we'll update the new value to match the new default
@@ -1835,8 +1751,8 @@
                 removeOldSchemaData[key] = undefined;
               }
             }
-            var newOptionConst = get__default["default"](newKeyedSchema, 'const', NO_VALUE);
-            var oldOptionConst = get__default["default"](oldKeyedSchema, 'const', NO_VALUE);
+            const newOptionConst = get__default["default"](newKeyedSchema, 'const', NO_VALUE);
+            const oldOptionConst = get__default["default"](oldKeyedSchema, 'const', NO_VALUE);
             if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
               // Since this is a const, if the old value matches, replace the value with the new const otherwise clear it
               removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : undefined;
@@ -1844,11 +1760,15 @@
           }
         }
       });
-      newFormData = _extends({}, data, removeOldSchemaData, nestedData);
+      newFormData = {
+        ...data,
+        ...removeOldSchemaData,
+        ...nestedData
+      };
       // First apply removing the old schema data, then apply the nested data, then apply the old data keys to keep
     } else if (get__default["default"](oldSchema, 'type') === 'array' && get__default["default"](newSchema, 'type') === 'array' && Array.isArray(data)) {
-      var oldSchemaItems = get__default["default"](oldSchema, 'items');
-      var newSchemaItems = get__default["default"](newSchema, 'items');
+      let oldSchemaItems = get__default["default"](oldSchema, 'items');
+      let newSchemaItems = get__default["default"](newSchema, 'items');
       // If any of the array types `items` are arrays (remember arrays are objects) then we'll just drop the data
       // Eventually, we may want to deal with when either of the `items` are arrays since those tuple validations
       if (typeof oldSchemaItems === 'object' && typeof newSchemaItems === 'object' && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
@@ -1859,14 +1779,14 @@
           newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
         }
         // Now get types and see if they are the same
-        var oldSchemaType = get__default["default"](oldSchemaItems, 'type');
-        var newSchemaType = get__default["default"](newSchemaItems, 'type');
+        const oldSchemaType = get__default["default"](oldSchemaItems, 'type');
+        const newSchemaType = get__default["default"](newSchemaItems, 'type');
         // Check if the old option has the same key with the same type
         if (!oldSchemaType || oldSchemaType === newSchemaType) {
-          var maxItems = get__default["default"](newSchema, 'maxItems', -1);
+          const maxItems = get__default["default"](newSchema, 'maxItems', -1);
           if (newSchemaType === 'object') {
-            newFormData = data.reduce(function (newValue, aValue) {
-              var itemValue = sanitizeDataForNewSchema(validator, rootSchema, newSchemaItems, oldSchemaItems, aValue);
+            newFormData = data.reduce((newValue, aValue) => {
+              const itemValue = sanitizeDataForNewSchema(validator, rootSchema, newSchemaItems, oldSchemaItems, aValue);
               if (itemValue !== undefined && (maxItems < 0 || newValue.length < maxItems)) {
                 newValue.push(itemValue);
               }
@@ -1899,15 +1819,10 @@
    * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
    * @returns - The `IdSchema` object for the `schema`
    */
-  function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList) {
-    if (_recurseList === void 0) {
-      _recurseList = [];
-    }
+  function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = []) {
     if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-      var _schema = retrieveSchema(validator, schema, rootSchema, formData);
-      var sameSchemaIndex = _recurseList.findIndex(function (item) {
-        return isEqual__default["default"](item, _schema);
-      });
+      const _schema = retrieveSchema(validator, schema, rootSchema, formData);
+      const sameSchemaIndex = _recurseList.findIndex(item => isEqual__default["default"](item, _schema));
       if (sameSchemaIndex === -1) {
         return toIdSchemaInternal(validator, _schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList.concat(_schema));
       }
@@ -1915,14 +1830,14 @@
     if (ITEMS_KEY in schema && !get__default["default"](schema, [ITEMS_KEY, REF_KEY])) {
       return toIdSchemaInternal(validator, get__default["default"](schema, ITEMS_KEY), idPrefix, idSeparator, id, rootSchema, formData, _recurseList);
     }
-    var $id = id || idPrefix;
-    var idSchema = {
-      $id: $id
+    const $id = id || idPrefix;
+    const idSchema = {
+      $id
     };
     if (getSchemaType(schema) === 'object' && PROPERTIES_KEY in schema) {
-      for (var name in schema.properties) {
-        var field = get__default["default"](schema, [PROPERTIES_KEY, name]);
-        var fieldId = idSchema[ID_KEY] + idSeparator + name;
+      for (const name in schema.properties) {
+        const field = get__default["default"](schema, [PROPERTIES_KEY, name]);
+        const fieldId = idSchema[ID_KEY] + idSeparator + name;
         idSchema[name] = toIdSchemaInternal(validator, isObject(field) ? field : {}, idPrefix, idSeparator, fieldId, rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
@@ -1942,13 +1857,7 @@
    * @param [idSeparator='_'] - The separator to use for the path segments in the id
    * @returns - The `IdSchema` object for the `schema`
    */
-  function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix, idSeparator) {
-    if (idPrefix === void 0) {
-      idPrefix = 'root';
-    }
-    if (idSeparator === void 0) {
-      idSeparator = '_';
-    }
+  function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = 'root', idSeparator = '_') {
     return toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData);
   }
 
@@ -1963,39 +1872,38 @@
    * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
    * @returns - The `PathSchema` object for the `schema`
    */
-  function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList) {
-    var _pathSchema;
-    if (_recurseList === void 0) {
-      _recurseList = [];
-    }
+  function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) {
     if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-      var _schema = retrieveSchema(validator, schema, rootSchema, formData);
-      var sameSchemaIndex = _recurseList.findIndex(function (item) {
-        return isEqual__default["default"](item, _schema);
-      });
+      const _schema = retrieveSchema(validator, schema, rootSchema, formData);
+      const sameSchemaIndex = _recurseList.findIndex(item => isEqual__default["default"](item, _schema));
       if (sameSchemaIndex === -1) {
         return toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList.concat(_schema));
       }
     }
-    var pathSchema = (_pathSchema = {}, _pathSchema[NAME_KEY] = name.replace(/^\./, ''), _pathSchema);
+    let pathSchema = {
+      [NAME_KEY]: name.replace(/^\./, '')
+    };
     if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
-      var xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
-      var discriminator = getDiscriminatorFieldFromSchema(schema);
-      var index = getClosestMatchingOption(validator, rootSchema, formData, xxxOf, 0, discriminator);
-      var _schema2 = xxxOf[index];
-      pathSchema = _extends({}, pathSchema, toPathSchemaInternal(validator, _schema2, name, rootSchema, formData, _recurseList));
+      const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
+      const discriminator = getDiscriminatorFieldFromSchema(schema);
+      const index = getClosestMatchingOption(validator, rootSchema, formData, xxxOf, 0, discriminator);
+      const _schema = xxxOf[index];
+      pathSchema = {
+        ...pathSchema,
+        ...toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList)
+      };
     }
     if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
       set__default["default"](pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true);
     }
     if (ITEMS_KEY in schema && Array.isArray(formData)) {
-      formData.forEach(function (element, i) {
-        pathSchema[i] = toPathSchemaInternal(validator, schema.items, name + "." + i, rootSchema, element, _recurseList);
+      formData.forEach((element, i) => {
+        pathSchema[i] = toPathSchemaInternal(validator, schema.items, `${name}.${i}`, rootSchema, element, _recurseList);
       });
     } else if (PROPERTIES_KEY in schema) {
-      for (var property in schema.properties) {
-        var field = get__default["default"](schema, [PROPERTIES_KEY, property]);
-        pathSchema[property] = toPathSchemaInternal(validator, field, name + "." + property, rootSchema,
+      for (const property in schema.properties) {
+        const field = get__default["default"](schema, [PROPERTIES_KEY, property]);
+        pathSchema[property] = toPathSchemaInternal(validator, field, `${name}.${property}`, rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
         get__default["default"](formData, [property]), _recurseList);
@@ -2012,10 +1920,7 @@
    * @param [formData] - The current formData, if any, to assist retrieving a schema
    * @returns - The `PathSchema` object for the `schema`
    */
-  function toPathSchema(validator, schema, name, rootSchema, formData) {
-    if (name === void 0) {
-      name = '';
-    }
+  function toPathSchema(validator, schema, name = '', rootSchema, formData) {
     return toPathSchemaInternal(validator, schema, name, rootSchema, formData);
   }
 
@@ -2024,14 +1929,14 @@
    * Since these generally do not change across a `Form`, this allows for providing a simplified set of APIs to the
    * `@rjsf/core` components and the various themes as well. This class implements the `SchemaUtilsType` interface.
    */
-  var SchemaUtils = /*#__PURE__*/function () {
+  class SchemaUtils {
     /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
      *
      * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
      * @param rootSchema - The root schema that will be forwarded to all the APIs
      * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior
      */
-    function SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior) {
+    constructor(validator, rootSchema, experimental_defaultFormStateBehavior) {
       this.rootSchema = void 0;
       this.validator = void 0;
       this.experimental_defaultFormStateBehavior = void 0;
@@ -2043,8 +1948,7 @@
      *
      * @returns - The `ValidatorType`
      */
-    var _proto = SchemaUtils.prototype;
-    _proto.getValidator = function getValidator() {
+    getValidator() {
       return this.validator;
     }
     /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of
@@ -2055,11 +1959,8 @@
      * @param rootSchema - The root schema that will be compared against the current one
      * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
      * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
-     */;
-    _proto.doesSchemaUtilsDiffer = function doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior) {
-      if (experimental_defaultFormStateBehavior === void 0) {
-        experimental_defaultFormStateBehavior = {};
-      }
+     */
+    doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
       if (!validator || !rootSchema) {
         return false;
       }
@@ -2074,11 +1975,8 @@
      *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
      *          object properties.
      * @returns - The resulting `formData` with all the defaults provided
-     */;
-    _proto.getDefaultFormState = function getDefaultFormState$1(schema, formData, includeUndefinedValues) {
-      if (includeUndefinedValues === void 0) {
-        includeUndefinedValues = false;
-      }
+     */
+    getDefaultFormState(schema, formData, includeUndefinedValues = false) {
       return getDefaultFormState(this.validator, schema, formData, this.rootSchema, includeUndefinedValues, this.experimental_defaultFormStateBehavior);
     }
     /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
@@ -2088,8 +1986,8 @@
      * @param [uiSchema] - The UI schema from which to derive potentially displayable information
      * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
      * @returns - True if the label should be displayed or false if it should not
-     */;
-    _proto.getDisplayLabel = function getDisplayLabel$1(schema, uiSchema, globalOptions) {
+     */
+    getDisplayLabel(schema, uiSchema, globalOptions) {
       return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema, globalOptions);
     }
     /** Determines which of the given `options` provided most closely matches the `formData`.
@@ -2104,8 +2002,8 @@
      * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
      *          determine which option is selected
      * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
-     */;
-    _proto.getClosestMatchingOption = function getClosestMatchingOption$1(formData, options, selectedOption, discriminatorField) {
+     */
+    getClosestMatchingOption(formData, options, selectedOption, discriminatorField) {
       return getClosestMatchingOption(this.validator, this.rootSchema, formData, options, selectedOption, discriminatorField);
     }
     /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
@@ -2116,8 +2014,8 @@
      * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
      *          determine which option is selected
      * @returns - The firstindex of the matched option or 0 if none is available
-     */;
-    _proto.getFirstMatchingOption = function getFirstMatchingOption$1(formData, options, discriminatorField) {
+     */
+    getFirstMatchingOption(formData, options, discriminatorField) {
       return getFirstMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
     }
     /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
@@ -2129,8 +2027,8 @@
      *          determine which option is selected
      * @returns - The index of the matched option or 0 if none is available
      * @deprecated
-     */;
-    _proto.getMatchingOption = function getMatchingOption$1(formData, options, discriminatorField) {
+     */
+    getMatchingOption(formData, options, discriminatorField) {
       return getMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
     }
     /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
@@ -2138,24 +2036,24 @@
      * @param schema - The schema for which check for array of files flag is desired
      * @param [uiSchema] - The UI schema from which to check the widget
      * @returns - True if schema/uiSchema contains an array of files, otherwise false
-     */;
-    _proto.isFilesArray = function isFilesArray$1(schema, uiSchema) {
+     */
+    isFilesArray(schema, uiSchema) {
       return isFilesArray(this.validator, schema, uiSchema, this.rootSchema);
     }
     /** Checks to see if the `schema` combination represents a multi-select
      *
      * @param schema - The schema for which check for a multi-select flag is desired
      * @returns - True if schema contains a multi-select, otherwise false
-     */;
-    _proto.isMultiSelect = function isMultiSelect$1(schema) {
+     */
+    isMultiSelect(schema) {
       return isMultiSelect(this.validator, schema, this.rootSchema);
     }
     /** Checks to see if the `schema` combination represents a select
      *
      * @param schema - The schema for which check for a select flag is desired
      * @returns - True if schema contains a select, otherwise false
-     */;
-    _proto.isSelect = function isSelect$1(schema) {
+     */
+    isSelect(schema) {
       return isSelect(this.validator, schema, this.rootSchema);
     }
     /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in
@@ -2168,8 +2066,8 @@
      * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
      * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
      *        removed in the next major release.
-     */;
-    _proto.mergeValidationData = function mergeValidationData$1(validationData, additionalErrorSchema) {
+     */
+    mergeValidationData(validationData, additionalErrorSchema) {
       return mergeValidationData(this.validator, validationData, additionalErrorSchema);
     }
     /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
@@ -2179,8 +2077,8 @@
      * @param schema - The schema for which retrieving a schema is desired
      * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
      * @returns - The schema having its conditions, additional properties, references and dependencies resolved
-     */;
-    _proto.retrieveSchema = function retrieveSchema$1(schema, rawFormData) {
+     */
+    retrieveSchema(schema, rawFormData) {
       return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData);
     }
     /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
@@ -2193,8 +2091,8 @@
      * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
      * @returns - The new form data, with all the fields uniquely associated with the old schema set
      *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
-     */;
-    _proto.sanitizeDataForNewSchema = function sanitizeDataForNewSchema$1(newSchema, oldSchema, data) {
+     */
+    sanitizeDataForNewSchema(newSchema, oldSchema, data) {
       return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
     }
     /** Generates an `IdSchema` object for the `schema`, recursively
@@ -2205,14 +2103,8 @@
      * @param [idPrefix='root'] - The prefix to use for the id
      * @param [idSeparator='_'] - The separator to use for the path segments in the id
      * @returns - The `IdSchema` object for the `schema`
-     */;
-    _proto.toIdSchema = function toIdSchema$1(schema, id, formData, idPrefix, idSeparator) {
-      if (idPrefix === void 0) {
-        idPrefix = 'root';
-      }
-      if (idSeparator === void 0) {
-        idSeparator = '_';
-      }
+     */
+    toIdSchema(schema, id, formData, idPrefix = 'root', idSeparator = '_') {
       return toIdSchema(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator);
     }
     /** Generates an `PathSchema` object for the `schema`, recursively
@@ -2221,12 +2113,11 @@
      * @param [name] - The base name for the schema
      * @param [formData] - The current formData, if any, onto which to provide any missing defaults
      * @returns - The `PathSchema` object for the `schema`
-     */;
-    _proto.toPathSchema = function toPathSchema$1(schema, name, formData) {
+     */
+    toPathSchema(schema, name, formData) {
       return toPathSchema(this.validator, schema, name, this.rootSchema, formData);
-    };
-    return SchemaUtils;
-  }();
+    }
+  }
   /** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The
    * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs.
    *
@@ -2235,10 +2126,7 @@
    * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
    * @returns - An implementation of a `SchemaUtilsType` interface
    */
-  function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior) {
-    if (experimental_defaultFormStateBehavior === void 0) {
-      experimental_defaultFormStateBehavior = {};
-    }
+  function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
     return new SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior);
   }
 
@@ -2250,17 +2138,17 @@
    */
   function dataURItoBlob(dataURI) {
     // Split metadata from data
-    var splitted = dataURI.split(',');
+    const splitted = dataURI.split(',');
     // Split params
-    var params = splitted[0].split(';');
+    const params = splitted[0].split(';');
     // Get mime-type from params
-    var type = params[0].replace('data:', '');
+    const type = params[0].replace('data:', '');
     // Filter the name property from params
-    var properties = params.filter(function (param) {
+    const properties = params.filter(param => {
       return param.split('=')[0] === 'name';
     });
     // Look for the name and use unknown if no name property.
-    var name;
+    let name;
     if (properties.length !== 1) {
       name = 'unknown';
     } else {
@@ -2270,18 +2158,18 @@
     }
     // Built the Uint8Array Blob parameter from the base64 string.
     try {
-      var binary = atob(splitted[1]);
-      var array = [];
-      for (var i = 0; i < binary.length; i++) {
+      const binary = atob(splitted[1]);
+      const array = [];
+      for (let i = 0; i < binary.length; i++) {
         array.push(binary.charCodeAt(i));
       }
       // Create the blob object
-      var blob = new window.Blob([new Uint8Array(array)], {
-        type: type
+      const blob = new window.Blob([new Uint8Array(array)], {
+        type
       });
       return {
-        blob: blob,
-        name: name
+        blob,
+        name
       };
     } catch (error) {
       return {
@@ -2303,13 +2191,11 @@
    * @returns - The updated string with any replacement specifiers replaced
    */
   function replaceStringParameters(inputString, params) {
-    var output = inputString;
+    let output = inputString;
     if (Array.isArray(params)) {
-      var parts = output.split(/(%\d)/);
-      params.forEach(function (param, index) {
-        var partIndex = parts.findIndex(function (part) {
-          return part === "%" + (index + 1);
-        });
+      const parts = output.split(/(%\d)/);
+      params.forEach((param, index) => {
+        const partIndex = parts.findIndex(part => part === `%${index + 1}`);
         if (partIndex >= 0) {
           parts[partIndex] = param;
         }
@@ -2342,20 +2228,13 @@
    * @returns - The single or list of values specified by the single or list of indexes if they are valid. Otherwise,
    *        `emptyValue` or an empty list.
    */
-  function enumOptionsValueForIndex(valueIndex, allEnumOptions, emptyValue) {
-    if (allEnumOptions === void 0) {
-      allEnumOptions = [];
-    }
+  function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
     if (Array.isArray(valueIndex)) {
-      return valueIndex.map(function (index) {
-        return enumOptionsValueForIndex(index, allEnumOptions);
-      }).filter(function (val) {
-        return val;
-      });
+      return valueIndex.map(index => enumOptionsValueForIndex(index, allEnumOptions)).filter(val => val);
     }
     // So Number(null) and Number('') both return 0, so use emptyValue for those two values
-    var index = valueIndex === '' || valueIndex === null ? -1 : Number(valueIndex);
-    var option = allEnumOptions[index];
+    const index = valueIndex === '' || valueIndex === null ? -1 : Number(valueIndex);
+    const option = allEnumOptions[index];
     return option ? option.value : emptyValue;
   }
 
@@ -2371,15 +2250,10 @@
    *        unless `selected` is a single value. In that case, if the `valueIndex` value matches `selected`, returns
    *        undefined, otherwise `selected`.
    */
-  function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions) {
-    if (allEnumOptions === void 0) {
-      allEnumOptions = [];
-    }
-    var value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+  function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
+    const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
     if (Array.isArray(selected)) {
-      return selected.filter(function (v) {
-        return !isEqual__default["default"](v, value);
-      });
+      return selected.filter(v => !isEqual__default["default"](v, value));
     }
     return isEqual__default["default"](value, selected) ? undefined : selected;
   }
@@ -2392,9 +2266,7 @@
    */
   function enumOptionsIsSelected(value, selected) {
     if (Array.isArray(selected)) {
-      return selected.some(function (sel) {
-        return isEqual__default["default"](sel, value);
-      });
+      return selected.some(sel => isEqual__default["default"](sel, value));
     }
     return isEqual__default["default"](selected, value);
   }
@@ -2410,18 +2282,8 @@
    * @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) {
-    if (allEnumOptions === void 0) {
-      allEnumOptions = [];
-    }
-    if (multiple === void 0) {
-      multiple = false;
-    }
-    var selectedIndexes = allEnumOptions.map(function (opt, index) {
-      return enumOptionsIsSelected(opt.value, value) ? String(index) : undefined;
-    }).filter(function (opt) {
-      return typeof opt !== 'undefined';
-    });
+  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];
     }
@@ -2436,25 +2298,17 @@
    * @param [allEnumOptions=[]] - The list of all the known enumOptions
    * @returns - The updated list of selected enum values with enum value at the `valueIndex` added to it
    */
-  function enumOptionsSelectValue(valueIndex, selected, allEnumOptions) {
-    if (allEnumOptions === void 0) {
-      allEnumOptions = [];
-    }
-    var value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+  function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
+    const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
     if (!lodashEs.isNil(value)) {
-      var index = allEnumOptions.findIndex(function (opt) {
-        return value === opt.value;
-      });
-      var all = allEnumOptions.map(function (_ref) {
-        var val = _ref.value;
-        return val;
-      });
-      var updated = selected.slice(0, index).concat(value, selected.slice(index));
+      const index = allEnumOptions.findIndex(opt => value === opt.value);
+      const all = allEnumOptions.map(({
+        value: val
+      }) => val);
+      const updated = selected.slice(0, index).concat(value, selected.slice(index));
       // As inserting values at predefined index positions doesn't work with empty
       // arrays, we need to reorder the updated selection to match the initial order
-      return updated.sort(function (a, b) {
-        return Number(all.indexOf(a) > all.indexOf(b));
-      });
+      return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
     }
     return selected;
   }
@@ -2464,12 +2318,12 @@
    * schema by using either dotted path or an array of path names. Once you are done building the `ErrorSchema`, you can
    * get the result and/or reset all the errors back to an initial set and start again.
    */
-  var ErrorSchemaBuilder = /*#__PURE__*/function () {
+  class ErrorSchemaBuilder {
     /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
      *
      * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
      */
-    function ErrorSchemaBuilder(initialSchema) {
+    constructor(initialSchema) {
       /** The error schema being built
        *
        * @private
@@ -2479,16 +2333,18 @@
     }
     /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
      */
-    var _proto = ErrorSchemaBuilder.prototype;
+    get ErrorSchema() {
+      return this.errorSchema;
+    }
     /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one.
      *
      * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
      * @returns - The error block for the given `pathOfError` or the root if not provided
      * @private
      */
-    _proto.getOrCreateErrorBlock = function getOrCreateErrorBlock(pathOfError) {
-      var hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === 'string';
-      var errorBlock = hasPath ? get__default["default"](this.errorSchema, pathOfError) : this.errorSchema;
+    getOrCreateErrorBlock(pathOfError) {
+      const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === 'string';
+      let errorBlock = hasPath ? get__default["default"](this.errorSchema, pathOfError) : this.errorSchema;
       if (!errorBlock && pathOfError) {
         errorBlock = {};
         set__default["default"](this.errorSchema, pathOfError, errorBlock);
@@ -2499,8 +2355,8 @@
      *
      * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
      * @returns - The `ErrorSchemaBuilder` object for chaining purposes
-     */;
-    _proto.resetAllErrors = function resetAllErrors(initialSchema) {
+     */
+    resetAllErrors(initialSchema) {
       this.errorSchema = initialSchema ? cloneDeep__default["default"](initialSchema) : {};
       return this;
     }
@@ -2511,17 +2367,16 @@
      * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
      * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
      * @returns - The `ErrorSchemaBuilder` object for chaining purposes
-     */;
-    _proto.addErrors = function addErrors(errorOrList, pathOfError) {
-      var errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      var errorsList = get__default["default"](errorBlock, ERRORS_KEY);
+     */
+    addErrors(errorOrList, pathOfError) {
+      const errorBlock = this.getOrCreateErrorBlock(pathOfError);
+      let errorsList = get__default["default"](errorBlock, ERRORS_KEY);
       if (!Array.isArray(errorsList)) {
         errorsList = [];
         errorBlock[ERRORS_KEY] = errorsList;
       }
       if (Array.isArray(errorOrList)) {
-        var _errorsList;
-        (_errorsList = errorsList).push.apply(_errorsList, errorOrList);
+        errorsList.push(...errorOrList);
       } else {
         errorsList.push(errorOrList);
       }
@@ -2534,11 +2389,11 @@
      * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
      * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
      * @returns - The `ErrorSchemaBuilder` object for chaining purposes
-     */;
-    _proto.setErrors = function setErrors(errorOrList, pathOfError) {
-      var errorBlock = this.getOrCreateErrorBlock(pathOfError);
+     */
+    setErrors(errorOrList, pathOfError) {
+      const errorBlock = this.getOrCreateErrorBlock(pathOfError);
       // Effectively clone the array being given to prevent accidental outside manipulation of the given list
-      var listToAdd = Array.isArray(errorOrList) ? [].concat(errorOrList) : [errorOrList];
+      const listToAdd = Array.isArray(errorOrList) ? [...errorOrList] : [errorOrList];
       set__default["default"](errorBlock, ERRORS_KEY, listToAdd);
       return this;
     }
@@ -2548,20 +2403,13 @@
      *
      * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
      * @returns - The `ErrorSchemaBuilder` object for chaining purposes
-     */;
-    _proto.clearErrors = function clearErrors(pathOfError) {
-      var errorBlock = this.getOrCreateErrorBlock(pathOfError);
+     */
+    clearErrors(pathOfError) {
+      const errorBlock = this.getOrCreateErrorBlock(pathOfError);
       set__default["default"](errorBlock, ERRORS_KEY, []);
       return this;
-    };
-    _createClass(ErrorSchemaBuilder, [{
-      key: "ErrorSchema",
-      get: function get() {
-        return this.errorSchema;
-      }
-    }]);
-    return ErrorSchemaBuilder;
-  }();
+    }
+  }
 
   /** Extracts the range spec information `{ step?: number, min?: number, max?: number }` that can be spread onto an HTML
    * input from the range analog in the schema `{ multipleOf?: number, minimum?: number, maximum?: number }`.
@@ -2570,7 +2418,7 @@
    * @returns - A range specification from the schema
    */
   function rangeSpec(schema) {
-    var spec = {};
+    const spec = {};
     if (schema.multipleOf) {
       spec.step = schema.multipleOf;
     }
@@ -2591,16 +2439,11 @@
    * @param [autoDefaultStepAny=true] - Determines whether to auto-default step=any when the type is number and no step
    * @returns - The extracted `InputPropsType` object
    */
-  function getInputProps(schema, defaultType, options, autoDefaultStepAny) {
-    if (options === void 0) {
-      options = {};
-    }
-    if (autoDefaultStepAny === void 0) {
-      autoDefaultStepAny = true;
-    }
-    var inputProps = _extends({
-      type: defaultType || 'text'
-    }, rangeSpec(schema));
+  function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = true) {
+    const inputProps = {
+      type: defaultType || 'text',
+      ...rangeSpec(schema)
+    };
     // If options.inputType is set use that as the input type
     if (options.inputType) {
       inputProps.type = options.inputType;
@@ -2631,7 +2474,7 @@
 
   /** The default submit button options, exported for testing purposes
    */
-  var DEFAULT_OPTIONS = {
+  const DEFAULT_OPTIONS = {
     props: {
       disabled: false
     },
@@ -2643,14 +2486,14 @@
    * @param [uiSchema={}] - the UI Schema from which to extract submit button props
    * @returns - The merging of the `DEFAULT_OPTIONS` with any custom ones
    */
-  function getSubmitButtonOptions(uiSchema) {
-    if (uiSchema === void 0) {
-      uiSchema = {};
-    }
-    var uiOptions = getUiOptions(uiSchema);
+  function getSubmitButtonOptions(uiSchema = {}) {
+    const uiOptions = getUiOptions(uiSchema);
     if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) {
-      var options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
-      return _extends({}, DEFAULT_OPTIONS, options);
+      const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
+      return {
+        ...DEFAULT_OPTIONS,
+        ...options
+      };
     }
     return DEFAULT_OPTIONS;
   }
@@ -2663,11 +2506,10 @@
    * @param [uiOptions={}] - The `UIOptionsType` from which to read an alternate template
    * @returns - The template from either the `uiSchema` or `registry` for the `name`
    */
-  function getTemplate(name, registry, uiOptions) {
-    if (uiOptions === void 0) {
-      uiOptions = {};
-    }
-    var templates = registry.templates;
+  function getTemplate(name, registry, uiOptions = {}) {
+    const {
+      templates
+    } = registry;
     if (name === 'ButtonTemplates') {
       return templates[name];
     }
@@ -2678,11 +2520,10 @@
     );
   }
 
-  var _excluded = ["options"];
   /** The map of schema types to widget type to widget name
    */
-  var widgetMap = {
-    "boolean": {
+  const widgetMap = {
+    boolean: {
       checkbox: 'CheckboxWidget',
       radio: 'RadioWidget',
       select: 'SelectWidget',
@@ -2741,16 +2582,21 @@
    * @returns - The wrapper widget
    */
   function mergeWidgetOptions(AWidget) {
-    var MergedWidget = get__default["default"](AWidget, 'MergedWidget');
+    let MergedWidget = get__default["default"](AWidget, 'MergedWidget');
     // cache return value as property of widget for proper react reconciliation
     if (!MergedWidget) {
-      var defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
-      MergedWidget = function MergedWidget(_ref) {
-        var options = _ref.options,
-          props = _objectWithoutPropertiesLoose(_ref, _excluded);
-        return jsxRuntime.jsx(AWidget, _extends({
-          options: _extends({}, defaultOptions, options)
-        }, props));
+      const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
+      MergedWidget = ({
+        options,
+        ...props
+      }) => {
+        return jsxRuntime.jsx(AWidget, {
+          options: {
+            ...defaultOptions,
+            ...options
+          },
+          ...props
+        });
       };
       set__default["default"](AWidget, 'MergedWidget', MergedWidget);
     }
@@ -2767,31 +2613,28 @@
    * @returns - The `Widget` component to use
    * @throws - An error if there is no `Widget` component that can be returned
    */
-  function getWidget(schema, widget, registeredWidgets) {
-    if (registeredWidgets === void 0) {
-      registeredWidgets = {};
-    }
-    var type = getSchemaType(schema);
+  function getWidget(schema, widget, registeredWidgets = {}) {
+    const type = getSchemaType(schema);
     if (typeof widget === 'function' || widget && ReactIs__default["default"].isForwardRef( /*#__PURE__*/react.createElement(widget)) || ReactIs__default["default"].isMemo(widget)) {
       return mergeWidgetOptions(widget);
     }
     if (typeof widget !== 'string') {
-      throw new Error("Unsupported widget definition: " + typeof widget);
+      throw new Error(`Unsupported widget definition: ${typeof widget}`);
     }
     if (widget in registeredWidgets) {
-      var registeredWidget = registeredWidgets[widget];
+      const registeredWidget = registeredWidgets[widget];
       return getWidget(schema, registeredWidget, registeredWidgets);
     }
     if (typeof type === 'string') {
       if (!(type in widgetMap)) {
-        throw new Error("No widget for type '" + type + "'");
+        throw new Error(`No widget for type '${type}'`);
       }
       if (widget in widgetMap[type]) {
-        var _registeredWidget = registeredWidgets[widgetMap[type][widget]];
-        return getWidget(schema, _registeredWidget, registeredWidgets);
+        const registeredWidget = registeredWidgets[widgetMap[type][widget]];
+        return getWidget(schema, registeredWidget, registeredWidgets);
       }
     }
-    throw new Error("No widget '" + widget + "' for type '" + type + "'");
+    throw new Error(`No widget '${widget}' for type '${type}'`);
   }
 
   /** JS has no built-in hashing function, so rolling our own
@@ -2802,9 +2645,9 @@
    * @returns - The resulting hash of the string in hex format
    */
   function hashString(string) {
-    var hash = 0;
-    for (var i = 0; i < string.length; i += 1) {
-      var chr = string.charCodeAt(i);
+    let hash = 0;
+    for (let i = 0; i < string.length; i += 1) {
+      const chr = string.charCodeAt(i);
       hash = (hash << 5) - hash + chr;
       hash = hash & hash; // Convert to 32bit integer
     }
@@ -2818,11 +2661,9 @@
    * @returns - The string obtained from the hash of the stringified schema
    */
   function hashForSchema(schema) {
-    var allKeys = new Set();
+    const allKeys = new Set();
     // solution source: https://stackoverflow.com/questions/16167581/sort-object-properties-and-json-stringify/53593328#53593328
-    JSON.stringify(schema, function (key, value) {
-      return allKeys.add(key), value;
-    });
+    JSON.stringify(schema, (key, value) => (allKeys.add(key), value));
     return hashString(JSON.stringify(schema, Array.from(allKeys).sort()));
   }
 
@@ -2834,15 +2675,12 @@
    * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
    * @returns - True if the widget exists, false otherwise
    */
-  function hasWidget(schema, widget, registeredWidgets) {
-    if (registeredWidgets === void 0) {
-      registeredWidgets = {};
-    }
+  function hasWidget(schema, widget, registeredWidgets = {}) {
     try {
       getWidget(schema, widget, registeredWidgets);
       return true;
     } catch (e) {
-      var err = e;
+      const err = e;
       if (err.message && (err.message.startsWith('No widget') || err.message.startsWith('Unsupported widget'))) {
         return false;
       }
@@ -2856,8 +2694,8 @@
    * @param suffix - The suffix to append to the id
    */
   function idGenerator(id, suffix) {
-    var theId = isString__default["default"](id) ? id : id[ID_KEY];
-    return theId + "__" + suffix;
+    const theId = isString__default["default"](id) ? id : id[ID_KEY];
+    return `${theId}__${suffix}`;
   }
   /** Return a consistent `id` for the field description element
    *
@@ -2907,12 +2745,9 @@
    * @param [includeExamples=false] - Optional flag, if true, will add the `examplesId` into the list
    * @returns - The string containing the list of ids for use in an `aria-describedBy` attribute
    */
-  function ariaDescribedByIds(id, includeExamples) {
-    if (includeExamples === void 0) {
-      includeExamples = false;
-    }
-    var examples = includeExamples ? " " + examplesId(id) : '';
-    return errorId(id) + " " + descriptionId(id) + " " + helpId(id) + examples;
+  function ariaDescribedByIds(id, includeExamples = false) {
+    const examples = includeExamples ? ` ${examplesId(id)}` : '';
+    return `${errorId(id)} ${descriptionId(id)} ${helpId(id)}${examples}`;
   }
   /** Return a consistent `id` for the `optionIndex`s of a `Radio` or `Checkboxes` widget
    *
@@ -2921,7 +2756,7 @@
    * @returns - An id for the option index based on the parent `id`
    */
   function optionId(id, optionIndex) {
-    return id + "-" + optionIndex;
+    return `${id}-${optionIndex}`;
   }
 
   function labelValue(label, hideLabel, fallback) {
@@ -2945,11 +2780,11 @@
    * @throws - Error when the schema does not have a constant value
    */
   function toConstant(schema) {
-    if (ENUM_KEY in schema && Array.isArray(schema["enum"]) && schema["enum"].length === 1) {
-      return schema["enum"][0];
+    if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
+      return schema.enum[0];
     }
     if (CONST_KEY in schema) {
-      return schema["const"];
+      return schema.const;
     }
     throw new Error('schema cannot be inferred as a constant');
   }
@@ -2965,28 +2800,28 @@
   function optionsList(schema) {
     // enumNames was deprecated in v5 and is intentionally omitted from the RJSFSchema type.
     // Cast the type to include enumNames so the feature still works.
-    var schemaWithEnumNames = schema;
+    const schemaWithEnumNames = schema;
     if (schemaWithEnumNames.enumNames && "development" !== 'production') {
       console.warn('The enumNames property is deprecated and may be removed in a future major release.');
     }
-    if (schema["enum"]) {
-      return schema["enum"].map(function (value, i) {
-        var label = schemaWithEnumNames.enumNames && schemaWithEnumNames.enumNames[i] || String(value);
+    if (schema.enum) {
+      return schema.enum.map((value, i) => {
+        const label = schemaWithEnumNames.enumNames && schemaWithEnumNames.enumNames[i] || String(value);
         return {
-          label: label,
-          value: value
+          label,
+          value
         };
       });
     }
-    var altSchemas = schema.oneOf || schema.anyOf;
-    return altSchemas && altSchemas.map(function (aSchemaDef) {
-      var aSchema = aSchemaDef;
-      var value = toConstant(aSchema);
-      var label = aSchema.title || String(value);
+    const altSchemas = schema.oneOf || schema.anyOf;
+    return altSchemas && altSchemas.map(aSchemaDef => {
+      const aSchema = aSchemaDef;
+      const value = toConstant(aSchema);
+      const label = aSchema.title || String(value);
       return {
         schema: aSchema,
-        label: label,
-        value: value
+        label,
+        value
       };
     });
   }
@@ -3005,35 +2840,27 @@
     if (!Array.isArray(order)) {
       return properties;
     }
-    var arrayToHash = function arrayToHash(arr) {
-      return arr.reduce(function (prev, curr) {
-        prev[curr] = true;
-        return prev;
-      }, {});
-    };
-    var errorPropList = function errorPropList(arr) {
-      return arr.length > 1 ? "properties '" + arr.join("', '") + "'" : "property '" + arr[0] + "'";
-    };
-    var propertyHash = arrayToHash(properties);
-    var orderFiltered = order.filter(function (prop) {
-      return prop === '*' || propertyHash[prop];
-    });
-    var orderHash = arrayToHash(orderFiltered);
-    var rest = properties.filter(function (prop) {
-      return !orderHash[prop];
-    });
-    var restIndex = orderFiltered.indexOf('*');
+    const arrayToHash = arr => arr.reduce((prev, curr) => {
+      prev[curr] = true;
+      return prev;
+    }, {});
+    const errorPropList = arr => arr.length > 1 ? `properties '${arr.join("', '")}'` : `property '${arr[0]}'`;
+    const propertyHash = arrayToHash(properties);
+    const orderFiltered = order.filter(prop => prop === '*' || propertyHash[prop]);
+    const orderHash = arrayToHash(orderFiltered);
+    const rest = properties.filter(prop => !orderHash[prop]);
+    const restIndex = orderFiltered.indexOf('*');
     if (restIndex === -1) {
       if (rest.length) {
-        throw new Error("uiSchema order list does not contain " + errorPropList(rest));
+        throw new Error(`uiSchema order list does not contain ${errorPropList(rest)}`);
       }
       return orderFiltered;
     }
     if (restIndex !== orderFiltered.lastIndexOf('*')) {
       throw new Error('uiSchema order list contains more than one wildcard item');
     }
-    var complete = [].concat(orderFiltered);
-    complete.splice.apply(complete, [restIndex, 1].concat(rest));
+    const complete = [...orderFiltered];
+    complete.splice(restIndex, 1, ...rest);
     return complete;
   }
 
@@ -3044,7 +2871,7 @@
    * @returns - The number converted to a string with leading zero padding if the number of digits is less than `width`
    */
   function pad(num, width) {
-    var s = String(num);
+    let s = String(num);
     while (s.length < width) {
       s = '0' + s;
     }
@@ -3058,10 +2885,7 @@
    * @returns - The date string converted to a `DateObject`
    * @throws - Error when the date cannot be parsed from the string
    */
-  function parseDateString(dateString, includeTime) {
-    if (includeTime === void 0) {
-      includeTime = true;
-    }
+  function parseDateString(dateString, includeTime = true) {
     if (!dateString) {
       return {
         year: -1,
@@ -3072,7 +2896,7 @@
         second: includeTime ? -1 : 0
       };
     }
-    var date = new Date(dateString);
+    const date = new Date(dateString);
     if (Number.isNaN(date.getTime())) {
       throw new Error('Unable to parse date ' + dateString);
     }
@@ -3097,11 +2921,11 @@
    */
   function schemaRequiresTrueValue(schema) {
     // Check if const is a truthy value
-    if (schema["const"]) {
+    if (schema.const) {
       return true;
     }
     // Check if an enum has a single value of true
-    if (schema["enum"] && schema["enum"].length === 1 && schema["enum"][0] === true) {
+    if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) {
       return true;
     }
     // If anyOf has a single value, evaluate the subschema
@@ -3114,9 +2938,7 @@
     }
     // Evaluate each subschema in allOf, to see if one of them requires a true value
     if (schema.allOf) {
-      var schemaSome = function schemaSome(subSchema) {
-        return schemaRequiresTrueValue(subSchema);
-      };
+      const schemaSome = subSchema => schemaRequiresTrueValue(subSchema);
       return schema.allOf.some(schemaSome);
     }
     return false;
@@ -3131,8 +2953,10 @@
    * @returns - True if the component should be re-rendered, false otherwise
    */
   function shouldRender(component, nextProps, nextState) {
-    var props = component.props,
-      state = component.state;
+    const {
+      props,
+      state
+    } = component;
     return !deepEquals(props, nextProps) || !deepEquals(state, nextState);
   }
 
@@ -3143,21 +2967,17 @@
    * @param [time=true] - Optional flag used to remove the time portion of the date string if false
    * @returns - The UTC date string
    */
-  function toDateString(dateObject, time) {
-    if (time === void 0) {
-      time = true;
-    }
-    var year = dateObject.year,
-      month = dateObject.month,
-      day = dateObject.day,
-      _dateObject$hour = dateObject.hour,
-      hour = _dateObject$hour === void 0 ? 0 : _dateObject$hour,
-      _dateObject$minute = dateObject.minute,
-      minute = _dateObject$minute === void 0 ? 0 : _dateObject$minute,
-      _dateObject$second = dateObject.second,
-      second = _dateObject$second === void 0 ? 0 : _dateObject$second;
-    var utcTime = Date.UTC(year, month - 1, day, hour, minute, second);
-    var datetime = new Date(utcTime).toJSON();
+  function toDateString(dateObject, time = true) {
+    const {
+      year,
+      month,
+      day,
+      hour = 0,
+      minute = 0,
+      second = 0
+    } = dateObject;
+    const utcTime = Date.UTC(year, month - 1, day, hour, minute, second);
+    const datetime = new Date(utcTime).toJSON();
     return time ? datetime : datetime.slice(0, 10);
   }
 
@@ -3167,29 +2987,26 @@
    * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
    * @returns - The list of `RJSFValidationErrors` extracted from the `errorSchema`
    */
-  function toErrorList(errorSchema, fieldPath) {
-    if (fieldPath === void 0) {
-      fieldPath = [];
-    }
+  function toErrorList(errorSchema, fieldPath = []) {
     if (!errorSchema) {
       return [];
     }
-    var errorList = [];
+    let errorList = [];
     if (ERRORS_KEY in errorSchema) {
-      errorList = errorList.concat(errorSchema[ERRORS_KEY].map(function (message) {
-        var property = "." + fieldPath.join('.');
+      errorList = errorList.concat(errorSchema[ERRORS_KEY].map(message => {
+        const property = `.${fieldPath.join('.')}`;
         return {
-          property: property,
-          message: message,
-          stack: property + " " + message
+          property,
+          message,
+          stack: `${property} ${message}`
         };
       }));
     }
-    return Object.keys(errorSchema).reduce(function (acc, key) {
+    return Object.keys(errorSchema).reduce((acc, key) => {
       if (key !== ERRORS_KEY) {
-        var childSchema = errorSchema[key];
+        const childSchema = errorSchema[key];
         if (isPlainObject__default["default"](childSchema)) {
-          acc = acc.concat(toErrorList(childSchema, [].concat(fieldPath, [key])));
+          acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
         }
       }
       return acc;
@@ -3216,13 +3033,15 @@
    * @returns - The `ErrorSchema` built from the list of `RJSFValidationErrors`
    */
   function toErrorSchema(errors) {
-    var builder = new ErrorSchemaBuilder();
+    const builder = new ErrorSchemaBuilder();
     if (errors.length) {
-      errors.forEach(function (error) {
-        var property = error.property,
-          message = error.message;
+      errors.forEach(error => {
+        const {
+          property,
+          message
+        } = error;
         // When the property is the root element, just use an empty array for the path
-        var path = property === '.' ? [] : toPath__default["default"](property);
+        const path = property === '.' ? [] : toPath__default["default"](property);
         // If the property is at the root (.level1) then toPath creates
         // an empty array element at the first index. Remove it.
         if (path.length > 0 && path[0] === '') {
@@ -3242,17 +3061,21 @@
    * @returns - The `ErrorSchema` resulting from the stripping of the `addError()` function
    */
   function unwrapErrorHandler(errorHandler) {
-    return Object.keys(errorHandler).reduce(function (acc, key) {
+    return Object.keys(errorHandler).reduce((acc, key) => {
       if (key === 'addError') {
         return acc;
       } else {
-        var _extends3;
-        var childSchema = errorHandler[key];
+        const childSchema = errorHandler[key];
         if (isPlainObject__default["default"](childSchema)) {
-          var _extends2;
-          return _extends({}, acc, (_extends2 = {}, _extends2[key] = unwrapErrorHandler(childSchema), _extends2));
+          return {
+            ...acc,
+            [key]: unwrapErrorHandler(childSchema)
+          };
         }
-        return _extends({}, acc, (_extends3 = {}, _extends3[key] = childSchema, _extends3));
+        return {
+          ...acc,
+          [key]: childSchema
+        };
       }
     }, {});
   }
@@ -3271,15 +3094,15 @@
     // > should be a _valid local date and time string_ (not GMT)
     // Note - date constructor passed local ISO-8601 does not correctly
     // change time to UTC in node pre-8
-    var date = new Date(jsonDate);
-    var yyyy = pad(date.getFullYear(), 4);
-    var MM = pad(date.getMonth() + 1, 2);
-    var dd = pad(date.getDate(), 2);
-    var hh = pad(date.getHours(), 2);
-    var mm = pad(date.getMinutes(), 2);
-    var ss = pad(date.getSeconds(), 2);
-    var SSS = pad(date.getMilliseconds(), 3);
-    return yyyy + "-" + MM + "-" + dd + "T" + hh + ":" + mm + ":" + ss + "." + SSS;
+    const date = new Date(jsonDate);
+    const yyyy = pad(date.getFullYear(), 4);
+    const MM = pad(date.getMonth() + 1, 2);
+    const dd = pad(date.getDate(), 2);
+    const hh = pad(date.getHours(), 2);
+    const mm = pad(date.getMinutes(), 2);
+    const ss = pad(date.getSeconds(), 2);
+    const SSS = pad(date.getMilliseconds(), 3);
+    return `${yyyy}-${MM}-${dd}T${hh}:${mm}:${ss}.${SSS}`;
   }
 
   /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
@@ -3295,17 +3118,19 @@
     if (!additionalErrorSchema) {
       return validationData;
     }
-    var oldErrors = validationData.errors,
-      oldErrorSchema = validationData.errorSchema;
-    var errors = toErrorList(additionalErrorSchema);
-    var errorSchema = additionalErrorSchema;
+    const {
+      errors: oldErrors,
+      errorSchema: oldErrorSchema
+    } = validationData;
+    let errors = toErrorList(additionalErrorSchema);
+    let errorSchema = additionalErrorSchema;
     if (!isEmpty__default["default"](oldErrorSchema)) {
       errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
-      errors = [].concat(oldErrors).concat(errors);
+      errors = [...oldErrors].concat(errors);
     }
     return {
-      errorSchema: errorSchema,
-      errors: errors
+      errorSchema,
+      errors
     };
   }
 
@@ -3315,9 +3140,9 @@
    * @param node - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
    */
   function withIdRefPrefixObject(node) {
-    for (var key in node) {
-      var realObj = node;
-      var value = realObj[key];
+    for (const key in node) {
+      const realObj = node;
+      const value = realObj[key];
       if (key === REF_KEY && typeof value === 'string' && value.startsWith('#')) {
         realObj[key] = ROOT_SCHEMA_PREFIX + value;
       } else {
@@ -3332,7 +3157,7 @@
    * @param node - The list of object nodes to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
    */
   function withIdRefPrefixArray(node) {
-    for (var i = 0; i < node.length; i++) {
+    for (let i = 0; i < node.length; i++) {
       node[i] = withIdRefPrefix(node[i]);
     }
     return node;
@@ -3344,11 +3169,13 @@
    * @returns - A copy of the `schemaNode` with updated `$ref`s
    */
   function withIdRefPrefix(schemaNode) {
-    if (schemaNode.constructor === Object) {
-      return withIdRefPrefixObject(_extends({}, schemaNode));
-    }
     if (Array.isArray(schemaNode)) {
-      return withIdRefPrefixArray([].concat(schemaNode));
+      return withIdRefPrefixArray([...schemaNode]);
+    }
+    if (isObject__default["default"](schemaNode)) {
+      return withIdRefPrefixObject({
+        ...schemaNode
+      });
     }
     return schemaNode;
   }
@@ -3436,13 +3263,13 @@
    * the hashed value of the schema. NOTE: After hashing the schema, an $id with the hash value is added to the
    * schema IF that schema doesn't already have an $id, prior to putting the schema into the map.
    */
-  var ParserValidator = /*#__PURE__*/function () {
+  class ParserValidator {
     /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
      * first.
      *
      * @param rootSchema - The root schema against which this validator will be executed
      */
-    function ParserValidator(rootSchema) {
+    constructor(rootSchema) {
       /** The rootSchema provided during construction of the class */
       this.rootSchema = void 0;
       /** The map of schemas encountered by the ParserValidator */
@@ -3457,23 +3284,24 @@
      * @param schema - The schema which is to be added to the map
      * @param hash - The hash value at which to map the schema
      */
-    var _proto = ParserValidator.prototype;
-    _proto.addSchema = function addSchema(schema, hash) {
-      var _extends2;
-      var key = get__default["default"](schema, ID_KEY, hash);
-      var identifiedSchema = _extends({}, schema, (_extends2 = {}, _extends2[ID_KEY] = key, _extends2));
-      var existing = this.schemaMap[key];
+    addSchema(schema, hash) {
+      const key = get__default["default"](schema, ID_KEY, hash);
+      const identifiedSchema = {
+        ...schema,
+        [ID_KEY]: key
+      };
+      const existing = this.schemaMap[key];
       if (!existing) {
         this.schemaMap[key] = identifiedSchema;
       } else if (!isEqual__default["default"](existing, identifiedSchema)) {
         console.error('existing schema:', JSON.stringify(existing, null, 2));
         console.error('new schema:', JSON.stringify(identifiedSchema, null, 2));
-        throw new Error("Two different schemas exist with the same key " + key + "! What a bad coincidence. If possible, try adding an $id to one of the schemas");
+        throw new Error(`Two different schemas exist with the same key ${key}! What a bad coincidence. If possible, try adding an $id to one of the schemas`);
       }
     }
     /** Returns the current `schemaMap` to the caller
-     */;
-    _proto.getSchemaMap = function getSchemaMap() {
+     */
+    getSchemaMap() {
       return this.schemaMap;
     }
     /** Implements the `ValidatorType` `isValid()` method to capture the `schema` in the `schemaMap`. Throws an error when
@@ -3483,8 +3311,8 @@
      * @param _formData - The formData parameter that is ignored
      * @param rootSchema - The root schema associated with the schema
      * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
-     */;
-    _proto.isValid = function isValid(schema, _formData, rootSchema) {
+     */
+    isValid(schema, _formData, rootSchema) {
       if (!isEqual__default["default"](rootSchema, this.rootSchema)) {
         throw new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema');
       }
@@ -3495,16 +3323,16 @@
      *
      * @param _schema - The schema parameter that is ignored
      * @param _formData - The formData parameter that is ignored
-     */;
-    _proto.rawValidation = function rawValidation(_schema, _formData) {
+     */
+    rawValidation(_schema, _formData) {
       throw new Error('Unexpectedly calling the `rawValidation()` method during schema parsing');
     }
     /** Implements the `ValidatorType` `toErrorList()` method to throw an error since it is never supposed to be called
      *
      * @param _errorSchema - The error schema parameter that is ignored
      * @param _fieldPath - The field path parameter that is ignored
-     */;
-    _proto.toErrorList = function toErrorList(_errorSchema, _fieldPath) {
+     */
+    toErrorList(_errorSchema, _fieldPath) {
       throw new Error('Unexpectedly calling the `toErrorList()` method during schema parsing');
     }
     /** Implements the `ValidatorType` `validateFormData()` method to throw an error since it is never supposed to be
@@ -3515,12 +3343,11 @@
      * @param _customValidate - The customValidate parameter that is ignored
      * @param _transformErrors - The transformErrors parameter that is ignored
      * @param _uiSchema - The uiSchema parameter that is ignored
-     */;
-    _proto.validateFormData = function validateFormData(_formData, _schema, _customValidate, _transformErrors, _uiSchema) {
+     */
+    validateFormData(_formData, _schema, _customValidate, _transformErrors, _uiSchema) {
       throw new Error('Unexpectedly calling the `validateFormData()` method during schema parsing');
-    };
-    return ParserValidator;
-  }();
+    }
+  }
 
   /** Recursive function used to parse the given `schema` belonging to the `rootSchema`. The `validator` is used to
    * capture the sub-schemas that the `isValid()` function is called with. For each schema returned by the
@@ -3533,17 +3360,15 @@
    * @param schema - The current schema element being parsed
    */
   function parseSchema(validator, recurseList, rootSchema, schema) {
-    var schemas = retrieveSchemaInternal(validator, schema, rootSchema, undefined, true);
-    schemas.forEach(function (schema) {
-      var sameSchemaIndex = recurseList.findIndex(function (item) {
-        return isEqual__default["default"](item, schema);
-      });
+    const schemas = retrieveSchemaInternal(validator, schema, rootSchema, undefined, true);
+    schemas.forEach(schema => {
+      const sameSchemaIndex = recurseList.findIndex(item => isEqual__default["default"](item, schema));
       if (sameSchemaIndex === -1) {
         recurseList.push(schema);
-        var allOptions = resolveAnyOrOneOfSchemas(validator, schema, rootSchema, true);
-        allOptions.forEach(function (s) {
+        const allOptions = resolveAnyOrOneOfSchemas(validator, schema, rootSchema, true);
+        allOptions.forEach(s => {
           if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
-            forEach__default["default"](schema[PROPERTIES_KEY], function (value) {
+            forEach__default["default"](schema[PROPERTIES_KEY], value => {
               parseSchema(validator, recurseList, rootSchema, value);
             });
           }
@@ -3561,8 +3386,8 @@
    * @returns - The `SchemaMap` of all schemas that were parsed
    */
   function schemaParser(rootSchema) {
-    var validator = new ParserValidator(rootSchema);
-    var recurseList = [];
+    const validator = new ParserValidator(rootSchema);
+    const recurseList = [];
     parseSchema(validator, recurseList, rootSchema, rootSchema);
     return validator.getSchemaMap();
   }