@rjsf/utils 5.10.0 → 5.11.1

package/dist/utils.esm.js

@@ -10,6 +10,7 @@ import isString from 'lodash-es/isString';
 import reduce from 'lodash-es/reduce';
 import times from 'lodash-es/times';
 import set from 'lodash-es/set';
+import forEach from 'lodash-es/forEach';
 import mergeAllOf from 'json-schema-merge-allof';
 import union from 'lodash-es/union';
 import isEqual from 'lodash-es/isEqual';
@@ -19,7 +20,6 @@ import { jsx } from 'react/jsx-runtime';
 import { createElement } from 'react';
 import ReactIs from 'react-is';
 import toPath from 'lodash-es/toPath';
-import forEach from 'lodash-es/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.
@@ -81,103 +81,42 @@ function asNumber(value) {
     // 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`.
@@ -186,27 +125,26 @@ var UI_GLOBAL_OPTIONS_KEY = 'ui:globalOptions';
  * @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
@@ -218,16 +156,13 @@ function getUiOptions(uiSchema, globalOptions) {
  * @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;
   }
@@ -245,21 +180,30 @@ function canExpand(schema, uiSchema, formData) {
  * @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(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;
@@ -273,7 +217,7 @@ function createErrorHandler(formData) {
  * @returns - True if the `a` and `b` are deeply equal, false otherwise
  */
 function deepEquals(a, b) {
-  return isEqualWith(a, b, function (obj, other) {
+  return isEqualWith(a, b, (obj, other) => {
     if (typeof obj === 'function' && typeof other === 'function') {
       // Assume all functions are equivalent
       // see https://github.com/rjsf-team/react-jsonschema-form/issues/255
@@ -292,8 +236,8 @@ function deepEquals(a, b) {
  *      value from `object[key]`
  */
 function splitKeyElementFromObject(key, object) {
-  var value = object[key];
-  var remaining = omit(object, [key]);
+  const value = object[key];
+  const remaining = omit(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
@@ -305,28 +249,26 @@ function splitKeyElementFromObject(key, object) {
  * @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.get(rootSchema, ref);
+  const current = jsonpointer.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;
   }
@@ -351,12 +293,12 @@ function getMatchingOption(validator, formData, options, rootSchema, discriminat
   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(option, [PROPERTIES_KEY, discriminatorField])) {
-      var value = get(formData, discriminatorField);
-      var discriminator = get(option, [PROPERTIES_KEY, discriminatorField], {});
+      const value = get(formData, discriminatorField);
+      const discriminator = get(option, [PROPERTIES_KEY, discriminatorField], {});
       if (validator.isValid(discriminator, value, rootSchema)) {
         return i;
       }
@@ -371,18 +313,18 @@ function getMatchingOption(validator, formData, options, rootSchema, discriminat
       //
       // 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 {
@@ -429,12 +371,12 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
  * @returns - The `discriminator.propertyName` if it exists in the schema, otherwise `undefined`
  */
 function getDiscriminatorFieldFromSchema(schema) {
-  var discriminator;
-  var maybeString = get(schema, 'discriminator.propertyName', undefined);
+  let discriminator;
+  const maybeString = get(schema, 'discriminator.propertyName', undefined);
   if (isString(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;
 }
@@ -480,20 +422,20 @@ function guessType(value) {
  * @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;
 }
@@ -507,9 +449,9 @@ function getSchemaType(schema) {
  * @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);
@@ -523,12 +465,6 @@ function mergeSchemas(obj1, obj2) {
   }, acc);
 }
 
-var _excluded$2 = ["if", "then", "else"],
-  _excluded2$1 = ["$ref"],
-  _excluded3 = ["allOf"],
-  _excluded4 = ["oneOf", "anyOf"],
-  _excluded5 = ["dependencies"],
-  _excluded6 = ["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.
@@ -539,10 +475,7 @@ var _excluded$2 = ["if", "then", "else"],
  * @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
@@ -558,13 +491,15 @@ function retrieveSchema(validator, schema, rootSchema, rawFormData) {
  * @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$2);
-  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));
@@ -573,19 +508,15 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, form
       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`.
@@ -602,19 +533,13 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, form
  * @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(permutations.length, function (i) {
-          return [].concat(permutations[i]).concat(element);
-        });
-      });
+      return list.flatMap(element => times(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
   );
@@ -638,21 +563,18 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, formDat
     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];
@@ -670,12 +592,48 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, formDat
  */
 function resolveReference(validator, schema, rootSchema, expandAllBranches, formData) {
   // Drop the $ref property of the source schema.
-  var $ref = schema.$ref,
-    localSchema = _objectWithoutPropertiesLoose(schema, _excluded2$1);
+  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(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`
  *
@@ -687,28 +645,34 @@ function resolveReference(validator, schema, rootSchema, expandAllBranches, form
  */
 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(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(formData, [key]))
@@ -740,36 +704,35 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
  * @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 resolvedSchema) {
+      // resolve allOf schemas
+      if (expandAllBranches) {
+        return [...resolvedSchema.allOf];
+      }
       try {
         resolvedSchema = mergeAllOf(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);
     }
@@ -789,11 +752,12 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
  * @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;
-  var _schema = schema,
-    oneOf = _schema.oneOf,
-    anyOf = _schema.anyOf,
-    remaining = _objectWithoutPropertiesLoose(_schema, _excluded4);
+  let anyOrOneOf;
+  const {
+    oneOf,
+    anyOf,
+    ...remaining
+  } = schema;
   if (Array.isArray(oneOf)) {
     anyOrOneOf = oneOf;
   } else if (Array.isArray(anyOf)) {
@@ -801,23 +765,17 @@ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranch
   }
   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.map(function (item) {
-        return _extends({}, remaining, item);
-      });
+      return anyOrOneOf.map(item => mergeSchemas(remaining, item));
     }
-    schema = _extends({}, remaining, anyOrOneOf[option]);
+    schema = mergeSchemas(remaining, anyOrOneOf[option]);
   }
   return [schema];
 }
@@ -834,12 +792,12 @@ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranch
  */
 function resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData) {
   // Drop the dependencies from the source schema.
-  var dependencies = schema.dependencies,
-    remainingSchema = _objectWithoutPropertiesLoose(schema, _excluded5);
-  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.
@@ -854,35 +812,24 @@ function resolveDependencies(validator, schema, rootSchema, expandAllBranches, f
  * @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(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;
 }
@@ -896,10 +843,11 @@ function withDependentProperties(schema, additionallyRequired) {
   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.
@@ -915,26 +863,26 @@ function withDependentProperties(schema, additionallyRequired) {
  * @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, _excluded6);
+  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
@@ -952,16 +900,19 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
  * @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;
     }
@@ -971,24 +922,22 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
     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: {
@@ -1017,41 +966,38 @@ var JUNK_OPTION = {
  * @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$1(schema.properties)) {
-      totalScore += reduce(schema.properties, function (score, value, key) {
-        var formValue = get(formData, key);
+      totalScore += reduce(schema.properties, (score, value, key) => {
+        const formValue = get(formData, key);
         if (typeof value === 'boolean') {
           return score;
         }
         if (has(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(value, ONE_OF_KEY) || has(value, ANY_OF_KEY)) && formValue) {
-          var _key = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
-          var discriminator = getDiscriminatorFieldFromSchema(value);
-          return score + getClosestMatchingOption(validator, rootSchema, formValue, get(value, _key), -1, discriminator);
+          const key = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+          const discriminator = getDiscriminatorFieldFromSchema(value);
+          return score + getClosestMatchingOption(validator, rootSchema, formValue, get(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;
@@ -1086,21 +1032,15 @@ function calculateIndexScore(validator, rootSchema, schema, formData) {
  *          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
-  var resolvedOptions = options.map(function (option) {
-    if (has(option, REF_KEY)) {
-      return retrieveSchema(validator, option, rootSchema, formData);
-    }
-    return option;
+  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 = resolvedOptions.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);
@@ -1113,29 +1053,30 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
   }
   if (!allValidIndexes.length) {
     // No indexes were valid, so we'll score all the options, add all the indexes
-    times(resolvedOptions.length, function (i) {
-      return allValidIndexes.push(i);
-    });
+    times(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 = resolvedOptions[index];
-      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;
@@ -1150,9 +1091,7 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
  * @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`
@@ -1171,13 +1110,10 @@ function isFixedItems(schema) {
  * @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);
       }
@@ -1185,13 +1121,13 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults)
     });
     // 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(defaults, key) : {}, get(formData, key), mergeExtraArrayDefaults);
       return acc;
     }, acc);
@@ -1208,19 +1144,16 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults)
  *          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);
           }
@@ -1242,7 +1175,7 @@ function mergeObjects(obj1, obj2, concatArrays) {
  * @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
@@ -1252,19 +1185,14 @@ function isConstant(schema) {
  * @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;
 }
@@ -1283,8 +1211,6 @@ function isMultiSelect(validator, schema, rootSchema) {
   return isSelect(validator, schema.items, rootSchema);
 }
 
-var _excluded$1 = ["oneOf"],
-  _excluded2 = ["anyOf"];
 /** Enum that indicates how `schema.additionalItems` should be handled by the `getInnerSchemaForArrayItem()` function.
  */
 var AdditionalItemsHandling;
@@ -1308,16 +1234,10 @@ var AdditionalItemsHandling;
  * @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;
       }
@@ -1349,23 +1269,17 @@ function getInnerSchemaForArrayItem(schema, additionalItems, idx) {
  * @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'
@@ -1398,100 +1312,98 @@ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValu
  * @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) {
-    var oneOf = schema.oneOf,
-      remaining = _objectWithoutPropertiesLoose(schema, _excluded$1);
+    const {
+      oneOf,
+      ...remaining
+    } = schema;
     if (oneOf.length === 0) {
       return undefined;
     }
-    var discriminator = getDiscriminatorFieldFromSchema(schema);
+    const discriminator = getDiscriminatorFieldFromSchema(schema);
     schemaToCompute = oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, oneOf, 0, discriminator)];
-    schemaToCompute = _extends({}, remaining, schemaToCompute);
+    schemaToCompute = mergeSchemas(remaining, schemaToCompute);
   } else if (ANY_OF_KEY in schema) {
-    var anyOf = schema.anyOf,
-      _remaining = _objectWithoutPropertiesLoose(schema, _excluded2);
+    const {
+      anyOf,
+      ...remaining
+    } = schema;
     if (anyOf.length === 0) {
       return undefined;
     }
-    var _discriminator = getDiscriminatorFieldFromSchema(schema);
-    schemaToCompute = anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, anyOf, 0, _discriminator)];
-    schemaToCompute = _extends({}, _remaining, schemaToCompute);
+    const discriminator = getDiscriminatorFieldFromSchema(schema);
+    schemaToCompute = anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty(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(schema, [PROPERTIES_KEY, key]), {
-            rootSchema: rootSchema,
-            _recurseList: _recurseList,
-            experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+          const computedDefault = computeDefaults(validator, get(schema, [PROPERTIES_KEY, key]), {
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
             includeUndefinedValues: includeUndefinedValues === true,
             parentDefaults: get(defaults, [key]),
             rawFormData: get(formData, [key]),
@@ -1502,31 +1414,25 @@ function computeDefaults(validator, rawSchema, _temp) {
         }, {});
         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(defaults, [key]),
               rawFormData: get(formData, [key]),
@@ -1540,54 +1446,54 @@ function computeDefaults(validator, rawSchema, _temp) {
       }
     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(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);
@@ -1608,26 +1514,24 @@ function computeDefaults(validator, rawSchema, _temp) {
  * @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);
   }
@@ -1642,10 +1546,7 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
  * @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
@@ -1661,15 +1562,12 @@ function isCustomWidget(uiSchema) {
  * @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;
@@ -1685,15 +1583,13 @@ function isFilesArray(validator, schema, uiSchema, rootSchema) {
  * @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);
   }
@@ -1725,21 +1621,23 @@ function mergeValidationData(validator, validationData, additionalErrorSchema) {
   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(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
@@ -1787,31 +1685,28 @@ var NO_VALUE = /*#__PURE__*/Symbol('no Value');
  * @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(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(oldSchema, PROPERTIES_KEY)) {
-      var properties = get(oldSchema, PROPERTIES_KEY, {});
-      Object.keys(properties).forEach(function (key) {
+      const properties = get(oldSchema, PROPERTIES_KEY, {});
+      Object.keys(properties).forEach(key => {
         if (has(data, key)) {
           removeOldSchemaData[key] = undefined;
         }
       });
     }
-    var keys = Object.keys(get(newSchema, PROPERTIES_KEY, {}));
+    const keys = Object.keys(get(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(data, key);
-      var oldKeyedSchema = get(oldSchema, [PROPERTIES_KEY, key], {});
-      var newKeyedSchema = get(newSchema, [PROPERTIES_KEY, key], {});
+    const nestedData = {};
+    keys.forEach(key => {
+      const formValue = get(data, key);
+      let oldKeyedSchema = get(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = get(newSchema, [PROPERTIES_KEY, key], {});
       // Resolve the refs if they exist
       if (has(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
@@ -1820,8 +1715,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
         newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
       }
       // Now get types and see if they are the same
-      var oldSchemaTypeForKey = get(oldKeyedSchema, 'type');
-      var newSchemaTypeForKey = get(newKeyedSchema, 'type');
+      const oldSchemaTypeForKey = get(oldKeyedSchema, 'type');
+      const newSchemaTypeForKey = get(newKeyedSchema, 'type');
       // Check if the old option has the same key with the same type
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if (has(removeOldSchemaData, key)) {
@@ -1831,7 +1726,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
         // 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;
@@ -1840,8 +1735,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           // 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(newKeyedSchema, 'default', NO_VALUE);
-          var oldOptionDefault = get(oldKeyedSchema, 'default', NO_VALUE);
+          const newOptionDefault = get(newKeyedSchema, 'default', NO_VALUE);
+          const oldOptionDefault = get(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
@@ -1851,8 +1746,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
               removeOldSchemaData[key] = undefined;
             }
           }
-          var newOptionConst = get(newKeyedSchema, 'const', NO_VALUE);
-          var oldOptionConst = get(oldKeyedSchema, 'const', NO_VALUE);
+          const newOptionConst = get(newKeyedSchema, 'const', NO_VALUE);
+          const oldOptionConst = get(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;
@@ -1860,11 +1755,15 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
         }
       }
     });
-    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(oldSchema, 'type') === 'array' && get(newSchema, 'type') === 'array' && Array.isArray(data)) {
-    var oldSchemaItems = get(oldSchema, 'items');
-    var newSchemaItems = get(newSchema, 'items');
+    let oldSchemaItems = get(oldSchema, 'items');
+    let newSchemaItems = get(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)) {
@@ -1875,14 +1774,14 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
         newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
       }
       // Now get types and see if they are the same
-      var oldSchemaType = get(oldSchemaItems, 'type');
-      var newSchemaType = get(newSchemaItems, 'type');
+      const oldSchemaType = get(oldSchemaItems, 'type');
+      const newSchemaType = get(newSchemaItems, 'type');
       // Check if the old option has the same key with the same type
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        var maxItems = get(newSchema, 'maxItems', -1);
+        const maxItems = get(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);
             }
@@ -1915,15 +1814,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
  * @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(item, _schema);
-    });
+    const _schema = retrieveSchema(validator, schema, rootSchema, formData);
+    const sameSchemaIndex = _recurseList.findIndex(item => isEqual(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(validator, _schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList.concat(_schema));
     }
@@ -1931,14 +1825,14 @@ function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSc
   if (ITEMS_KEY in schema && !get(schema, [ITEMS_KEY, REF_KEY])) {
     return toIdSchemaInternal(validator, get(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(schema, [PROPERTIES_KEY, name]);
-      var fieldId = idSchema[ID_KEY] + idSeparator + name;
+    for (const name in schema.properties) {
+      const field = get(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
@@ -1958,13 +1852,7 @@ function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSc
  * @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);
 }
 
@@ -1979,39 +1867,38 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix, idSep
  * @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(item, _schema);
-    });
+    const _schema = retrieveSchema(validator, schema, rootSchema, formData);
+    const sameSchemaIndex = _recurseList.findIndex(item => isEqual(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(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(schema, [PROPERTIES_KEY, property]);
-      pathSchema[property] = toPathSchemaInternal(validator, field, name + "." + property, rootSchema,
+    for (const property in schema.properties) {
+      const field = get(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(formData, [property]), _recurseList);
@@ -2028,10 +1915,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
  * @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);
 }
 
@@ -2040,14 +1924,14 @@ function toPathSchema(validator, schema, name, rootSchema, formData) {
  * 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;
@@ -2059,8 +1943,7 @@ var SchemaUtils = /*#__PURE__*/function () {
    *
    * @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
@@ -2071,11 +1954,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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;
     }
@@ -2090,11 +1970,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    *          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`
@@ -2104,8 +1981,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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`.
@@ -2120,8 +1997,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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.
@@ -2132,8 +2009,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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.
@@ -2145,8 +2022,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    *          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
@@ -2154,24 +2031,24 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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
@@ -2184,8 +2061,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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
@@ -2195,8 +2072,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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
@@ -2209,8 +2086,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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
@@ -2221,14 +2098,8 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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
@@ -2237,12 +2108,11 @@ var SchemaUtils = /*#__PURE__*/function () {
    * @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.
  *
@@ -2251,10 +2121,7 @@ var SchemaUtils = /*#__PURE__*/function () {
  * @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);
 }
 
@@ -2266,17 +2133,17 @@ function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateB
  */
 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 {
@@ -2286,18 +2153,18 @@ function dataURItoBlob(dataURI) {
   }
   // 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 {
@@ -2319,13 +2186,11 @@ function dataURItoBlob(dataURI) {
  * @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;
       }
@@ -2358,20 +2223,13 @@ function englishStringTranslator(stringToTranslate, params) {
  * @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;
 }
 
@@ -2387,15 +2245,10 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions, emptyValue) {
  *        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(v, value);
-    });
+    return selected.filter(v => !isEqual(v, value));
   }
   return isEqual(value, selected) ? undefined : selected;
 }
@@ -2408,9 +2261,7 @@ function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions) {
  */
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some(function (sel) {
-      return isEqual(sel, value);
-    });
+    return selected.some(sel => isEqual(sel, value));
   }
   return isEqual(selected, value);
 }
@@ -2426,18 +2277,8 @@ function enumOptionsIsSelected(value, selected) {
  * @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];
   }
@@ -2452,25 +2293,17 @@ function enumOptionsIndexForValue(value, allEnumOptions, multiple) {
  * @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 (!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;
 }
@@ -2480,12 +2313,12 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions) {
  * 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
@@ -2495,16 +2328,18 @@ var ErrorSchemaBuilder = /*#__PURE__*/function () {
   }
   /** 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(this.errorSchema, pathOfError) : this.errorSchema;
+  getOrCreateErrorBlock(pathOfError) {
+    const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === 'string';
+    let errorBlock = hasPath ? get(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       set(this.errorSchema, pathOfError, errorBlock);
@@ -2515,8 +2350,8 @@ var ErrorSchemaBuilder = /*#__PURE__*/function () {
    *
    * @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(initialSchema) : {};
     return this;
   }
@@ -2527,17 +2362,16 @@ var ErrorSchemaBuilder = /*#__PURE__*/function () {
    * @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(errorBlock, ERRORS_KEY);
+   */
+  addErrors(errorOrList, pathOfError) {
+    const errorBlock = this.getOrCreateErrorBlock(pathOfError);
+    let errorsList = get(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);
     }
@@ -2550,11 +2384,11 @@ var ErrorSchemaBuilder = /*#__PURE__*/function () {
    * @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(errorBlock, ERRORS_KEY, listToAdd);
     return this;
   }
@@ -2564,20 +2398,13 @@ var ErrorSchemaBuilder = /*#__PURE__*/function () {
    *
    * @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(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 }`.
@@ -2586,7 +2413,7 @@ var ErrorSchemaBuilder = /*#__PURE__*/function () {
  * @returns - A range specification from the schema
  */
 function rangeSpec(schema) {
-  var spec = {};
+  const spec = {};
   if (schema.multipleOf) {
     spec.step = schema.multipleOf;
   }
@@ -2607,16 +2434,11 @@ function rangeSpec(schema) {
  * @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;
@@ -2647,7 +2469,7 @@ function getInputProps(schema, defaultType, options, autoDefaultStepAny) {
 
 /** The default submit button options, exported for testing purposes
  */
-var DEFAULT_OPTIONS = {
+const DEFAULT_OPTIONS = {
   props: {
     disabled: false
   },
@@ -2659,14 +2481,14 @@ var DEFAULT_OPTIONS = {
  * @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;
 }
@@ -2679,11 +2501,10 @@ function getSubmitButtonOptions(uiSchema) {
  * @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];
   }
@@ -2694,11 +2515,10 @@ function getTemplate(name, registry, uiOptions) {
   );
 }
 
-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',
@@ -2757,16 +2577,21 @@ var widgetMap = {
  * @returns - The wrapper widget
  */
 function mergeWidgetOptions(AWidget) {
-  var MergedWidget = get(AWidget, 'MergedWidget');
+  let MergedWidget = get(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 jsx(AWidget, _extends({
-        options: _extends({}, defaultOptions, options)
-      }, props));
+    const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
+    MergedWidget = ({
+      options,
+      ...props
+    }) => {
+      return jsx(AWidget, {
+        options: {
+          ...defaultOptions,
+          ...options
+        },
+        ...props
+      });
     };
     set(AWidget, 'MergedWidget', MergedWidget);
   }
@@ -2783,31 +2608,28 @@ function mergeWidgetOptions(AWidget) {
  * @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.isForwardRef( /*#__PURE__*/createElement(widget)) || ReactIs.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
@@ -2818,9 +2640,9 @@ function getWidget(schema, widget, registeredWidgets) {
  * @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
   }
@@ -2834,11 +2656,9 @@ function hashString(string) {
  * @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()));
 }
 
@@ -2850,15 +2670,12 @@ function hashForSchema(schema) {
  * @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;
     }
@@ -2872,8 +2689,8 @@ function hasWidget(schema, widget, registeredWidgets) {
  * @param suffix - The suffix to append to the id
  */
 function idGenerator(id, suffix) {
-  var theId = isString(id) ? id : id[ID_KEY];
-  return theId + "__" + suffix;
+  const theId = isString(id) ? id : id[ID_KEY];
+  return `${theId}__${suffix}`;
 }
 /** Return a consistent `id` for the field description element
  *
@@ -2923,12 +2740,9 @@ function titleId(id) {
  * @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
  *
@@ -2937,7 +2751,7 @@ function ariaDescribedByIds(id, includeExamples) {
  * @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) {
@@ -2961,11 +2775,11 @@ function localToUTC(dateString) {
  * @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');
 }
@@ -2981,28 +2795,28 @@ function toConstant(schema) {
 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 && process.env.NODE_ENV !== '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
     };
   });
 }
@@ -3021,35 +2835,27 @@ function orderProperties(properties, order) {
   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;
 }
 
@@ -3060,7 +2866,7 @@ function orderProperties(properties, order) {
  * @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;
   }
@@ -3074,10 +2880,7 @@ function pad(num, width) {
  * @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,
@@ -3088,7 +2891,7 @@ function parseDateString(dateString, includeTime) {
       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);
   }
@@ -3113,11 +2916,11 @@ function parseDateString(dateString, includeTime) {
  */
 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
@@ -3130,9 +2933,7 @@ function schemaRequiresTrueValue(schema) {
   }
   // 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;
@@ -3147,8 +2948,10 @@ function schemaRequiresTrueValue(schema) {
  * @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);
 }
 
@@ -3159,21 +2962,17 @@ function shouldRender(component, nextProps, nextState) {
  * @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);
 }
 
@@ -3183,29 +2982,26 @@ function toDateString(dateObject, time) {
  * @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(childSchema)) {
-        acc = acc.concat(toErrorList(childSchema, [].concat(fieldPath, [key])));
+        acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
       }
     }
     return acc;
@@ -3232,13 +3028,15 @@ function toErrorList(errorSchema, fieldPath) {
  * @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(property);
+      const path = property === '.' ? [] : toPath(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] === '') {
@@ -3258,17 +3056,21 @@ function toErrorSchema(errors) {
  * @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(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
+      };
     }
   }, {});
 }
@@ -3287,15 +3089,15 @@ function utcToLocal(jsonDate) {
   // > 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
@@ -3311,17 +3113,19 @@ function validationDataMerge(validationData, additionalErrorSchema) {
   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(oldErrorSchema)) {
     errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
-    errors = [].concat(oldErrors).concat(errors);
+    errors = [...oldErrors].concat(errors);
   }
   return {
-    errorSchema: errorSchema,
-    errors: errors
+    errorSchema,
+    errors
   };
 }
 
@@ -3331,9 +3135,9 @@ function validationDataMerge(validationData, additionalErrorSchema) {
  * @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 {
@@ -3348,7 +3152,7 @@ function withIdRefPrefixObject(node) {
  * @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;
@@ -3360,11 +3164,13 @@ function withIdRefPrefixArray(node) {
  * @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$1(schemaNode)) {
+    return withIdRefPrefixObject({
+      ...schemaNode
+    });
   }
   return schemaNode;
 }
@@ -3452,13 +3258,13 @@ var TranslatableString;
  * 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 */
@@ -3473,23 +3279,24 @@ var ParserValidator = /*#__PURE__*/function () {
    * @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(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(schema, ID_KEY, hash);
+    const identifiedSchema = {
+      ...schema,
+      [ID_KEY]: key
+    };
+    const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
     } else if (!isEqual(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
@@ -3499,8 +3306,8 @@ var ParserValidator = /*#__PURE__*/function () {
    * @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(rootSchema, this.rootSchema)) {
       throw new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema');
     }
@@ -3511,16 +3318,16 @@ var ParserValidator = /*#__PURE__*/function () {
    *
    * @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
@@ -3531,12 +3338,11 @@ var ParserValidator = /*#__PURE__*/function () {
    * @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
@@ -3549,17 +3355,15 @@ var ParserValidator = /*#__PURE__*/function () {
  * @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(item, schema);
-    });
+  const schemas = retrieveSchemaInternal(validator, schema, rootSchema, undefined, true);
+  schemas.forEach(schema => {
+    const sameSchemaIndex = recurseList.findIndex(item => isEqual(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(schema[PROPERTIES_KEY], function (value) {
+          forEach(schema[PROPERTIES_KEY], value => {
             parseSchema(validator, recurseList, rootSchema, value);
           });
         }
@@ -3577,8 +3381,8 @@ function parseSchema(validator, recurseList, rootSchema, schema) {
  * @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();
 }