@rjsf/core 5.0.0-beta.14 → 5.0.0-beta.15

package/dist/core.cjs.development.js

@@ -26,6 +26,96 @@ var unset__default = /*#__PURE__*/_interopDefaultLegacy(unset);
 var has__default = /*#__PURE__*/_interopDefaultLegacy(has);
 var omit__default = /*#__PURE__*/_interopDefaultLegacy(omit);
 
+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, 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 _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+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 _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var _excluded$9 = ["widget"],
+  _excluded2 = ["widget"],
+  _excluded3 = ["widget"];
 /** Used to generate a unique ID for an element in a row */
 function generateRowId() {
   return nanoid.nanoid();
@@ -36,10 +126,10 @@ function generateRowId() {
  * @returns - The `formData` converted into a `KeyedFormDataType` element
  */
 function generateKeyedFormData(formData) {
-  return !Array.isArray(formData) ? [] : formData.map(item => {
+  return !Array.isArray(formData) ? [] : formData.map(function (item) {
     return {
       key: generateRowId(),
-      item
+      item: item
     };
   });
 }
@@ -50,96 +140,90 @@ function generateKeyedFormData(formData) {
  */
 function keyedToPlainFormData(keyedFormData) {
   if (Array.isArray(keyedFormData)) {
-    return keyedFormData.map(keyedItem => keyedItem.item);
+    return keyedFormData.map(function (keyedItem) {
+      return keyedItem.item;
+    });
   }
   return [];
 }
 /** The `ArrayField` component is used to render a field in the schema that is of type `array`. It supports both normal
  * and fixed array, allowing user to add and remove elements from the array data.
  */
-class ArrayField extends React.Component {
+var ArrayField = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(ArrayField, _Component);
   /** Constructs an `ArrayField` from the `props`, generating the initial keyed data from the `formData`
    *
    * @param props - The `FieldProps` for this template
    */
-  constructor(props) {
-    super(props);
-    this._getNewFormDataRow = () => {
-      const {
-        schema,
-        registry
-      } = this.props;
-      const {
-        schemaUtils
-      } = registry;
-      let itemSchema = schema.items;
+  function ArrayField(props) {
+    var _this;
+    _this = _Component.call(this, props) || this;
+    _this._getNewFormDataRow = function () {
+      var _this$props = _this.props,
+        schema = _this$props.schema,
+        registry = _this$props.registry;
+      var schemaUtils = registry.schemaUtils;
+      var itemSchema = schema.items;
       if (utils.isFixedItems(schema) && utils.allowAdditionalItems(schema)) {
         itemSchema = schema.additionalItems;
       }
       // Cast this as a T to work around schema utils being for T[] caused by the FieldProps<T[], S, F> call on the class
       return schemaUtils.getDefaultFormState(itemSchema);
     };
-    this.onAddClick = event => {
+    _this.onAddClick = function (event) {
       if (event) {
         event.preventDefault();
       }
-      const {
-        onChange
-      } = this.props;
-      const {
-        keyedFormData
-      } = this.state;
-      const newKeyedFormDataRow = {
+      var onChange = _this.props.onChange;
+      var keyedFormData = _this.state.keyedFormData;
+      var newKeyedFormDataRow = {
         key: generateRowId(),
-        item: this._getNewFormDataRow()
+        item: _this._getNewFormDataRow()
       };
-      const newKeyedFormData = [...keyedFormData, newKeyedFormDataRow];
-      this.setState({
+      var newKeyedFormData = [].concat(keyedFormData, [newKeyedFormDataRow]);
+      _this.setState({
         keyedFormData: newKeyedFormData,
         updatedKeyedFormData: true
-      }, () => onChange(keyedToPlainFormData(newKeyedFormData)));
+      }, function () {
+        return onChange(keyedToPlainFormData(newKeyedFormData));
+      });
     };
-    this.onAddIndexClick = index => {
-      return event => {
+    _this.onAddIndexClick = function (index) {
+      return function (event) {
         if (event) {
           event.preventDefault();
         }
-        const {
-          onChange
-        } = this.props;
-        const {
-          keyedFormData
-        } = this.state;
-        const newKeyedFormDataRow = {
+        var onChange = _this.props.onChange;
+        var keyedFormData = _this.state.keyedFormData;
+        var newKeyedFormDataRow = {
           key: generateRowId(),
-          item: this._getNewFormDataRow()
+          item: _this._getNewFormDataRow()
         };
-        const newKeyedFormData = [...keyedFormData];
+        var newKeyedFormData = [].concat(keyedFormData);
         newKeyedFormData.splice(index, 0, newKeyedFormDataRow);
-        this.setState({
+        _this.setState({
           keyedFormData: newKeyedFormData,
           updatedKeyedFormData: true
-        }, () => onChange(keyedToPlainFormData(newKeyedFormData)));
+        }, function () {
+          return onChange(keyedToPlainFormData(newKeyedFormData));
+        });
       };
     };
-    this.onDropIndexClick = index => {
-      return event => {
+    _this.onDropIndexClick = function (index) {
+      return function (event) {
         if (event) {
           event.preventDefault();
         }
-        const {
-          onChange,
-          errorSchema
-        } = this.props;
-        const {
-          keyedFormData
-        } = this.state;
+        var _this$props2 = _this.props,
+          onChange = _this$props2.onChange,
+          errorSchema = _this$props2.errorSchema;
+        var keyedFormData = _this.state.keyedFormData;
         // refs #195: revalidate to ensure properly reindexing errors
-        let newErrorSchema;
+        var newErrorSchema;
         if (errorSchema) {
           newErrorSchema = {};
-          for (const idx in errorSchema) {
-            const i = parseInt(idx);
+          for (var idx in errorSchema) {
+            var i = parseInt(idx);
             if (i < index) {
               set__default["default"](newErrorSchema, [i], errorSchema[idx]);
             } else if (i > index) {
@@ -147,28 +231,31 @@ class ArrayField extends React.Component {
             }
           }
         }
-        const newKeyedFormData = keyedFormData.filter((_, i) => i !== index);
-        this.setState({
+        var newKeyedFormData = keyedFormData.filter(function (_, i) {
+          return i !== index;
+        });
+        _this.setState({
           keyedFormData: newKeyedFormData,
           updatedKeyedFormData: true
-        }, () => onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema));
+        }, function () {
+          return onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema);
+        });
       };
     };
-    this.onReorderClick = (index, newIndex) => {
-      return event => {
+    _this.onReorderClick = function (index, newIndex) {
+      return function (event) {
         if (event) {
           event.preventDefault();
           event.currentTarget.blur();
         }
-        const {
-          onChange,
-          errorSchema
-        } = this.props;
-        let newErrorSchema;
-        if (this.props.errorSchema) {
+        var _this$props3 = _this.props,
+          onChange = _this$props3.onChange,
+          errorSchema = _this$props3.errorSchema;
+        var newErrorSchema;
+        if (_this.props.errorSchema) {
           newErrorSchema = {};
-          for (const idx in errorSchema) {
-            const i = parseInt(idx);
+          for (var idx in errorSchema) {
+            var i = parseInt(idx);
             if (i == index) {
               set__default["default"](newErrorSchema, [newIndex], errorSchema[index]);
             } else if (i == newIndex) {
@@ -178,58 +265,54 @@ class ArrayField extends React.Component {
             }
           }
         }
-        const {
-          keyedFormData
-        } = this.state;
+        var keyedFormData = _this.state.keyedFormData;
         function reOrderArray() {
           // Copy item
-          const _newKeyedFormData = keyedFormData.slice();
+          var _newKeyedFormData = keyedFormData.slice();
           // Moves item from index to newIndex
           _newKeyedFormData.splice(index, 1);
           _newKeyedFormData.splice(newIndex, 0, keyedFormData[index]);
           return _newKeyedFormData;
         }
-        const newKeyedFormData = reOrderArray();
-        this.setState({
+        var newKeyedFormData = reOrderArray();
+        _this.setState({
           keyedFormData: newKeyedFormData
-        }, () => onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema));
+        }, function () {
+          return onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema);
+        });
       };
     };
-    this.onChangeForIndex = index => {
-      return (value, newErrorSchema, id) => {
-        const {
-          formData,
-          onChange,
-          errorSchema
-        } = this.props;
-        const arrayData = Array.isArray(formData) ? formData : [];
-        const newFormData = arrayData.map((item, i) => {
+    _this.onChangeForIndex = function (index) {
+      return function (value, newErrorSchema, id) {
+        var _extends2;
+        var _this$props4 = _this.props,
+          formData = _this$props4.formData,
+          onChange = _this$props4.onChange,
+          errorSchema = _this$props4.errorSchema;
+        var arrayData = Array.isArray(formData) ? formData : [];
+        var newFormData = arrayData.map(function (item, i) {
           // We need to treat undefined items as nulls to have validation.
           // See https://github.com/tdegrunt/jsonschema/issues/206
-          const jsonValue = typeof value === "undefined" ? null : value;
+          var jsonValue = typeof value === "undefined" ? null : value;
           return index === i ? jsonValue : item;
         });
-        onChange(newFormData, errorSchema && errorSchema && {
-          ...errorSchema,
-          [index]: newErrorSchema
-        }, id);
+        onChange(newFormData, errorSchema && errorSchema && _extends({}, errorSchema, (_extends2 = {}, _extends2[index] = newErrorSchema, _extends2)), id);
       };
     };
-    this.onSelectChange = value => {
-      const {
-        onChange,
-        idSchema
-      } = this.props;
+    _this.onSelectChange = function (value) {
+      var _this$props5 = _this.props,
+        onChange = _this$props5.onChange,
+        idSchema = _this$props5.idSchema;
       onChange(value, undefined, idSchema && idSchema.$id);
     };
-    const {
-      formData: _formData = []
-    } = props;
-    const _keyedFormData = generateKeyedFormData(_formData);
-    this.state = {
+    var _props$formData = props.formData,
+      _formData = _props$formData === void 0 ? [] : _props$formData;
+    var _keyedFormData = generateKeyedFormData(_formData);
+    _this.state = {
       keyedFormData: _keyedFormData,
       updatedKeyedFormData: false
     };
+    return _this;
   }
   /** React lifecycle method that is called when the props are about to change allowing the state to be updated. It
    * regenerates the keyed form data and returns it
@@ -237,16 +320,16 @@ class ArrayField extends React.Component {
    * @param nextProps - The next set of props data
    * @param prevState - The previous set of state data
    */
-  static getDerivedStateFromProps(nextProps, prevState) {
+  ArrayField.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
     // Don't call getDerivedStateFromProps if keyed formdata was just updated.
     if (prevState.updatedKeyedFormData) {
       return {
         updatedKeyedFormData: false
       };
     }
-    const nextFormData = Array.isArray(nextProps.formData) ? nextProps.formData : [];
-    const previousKeyedFormData = prevState.keyedFormData || [];
-    const newKeyedFormData = nextFormData.length === previousKeyedFormData.length ? previousKeyedFormData.map((previousKeyedFormDatum, index) => {
+    var nextFormData = Array.isArray(nextProps.formData) ? nextProps.formData : [];
+    var previousKeyedFormData = prevState.keyedFormData || [];
+    var newKeyedFormData = nextFormData.length === previousKeyedFormData.length ? previousKeyedFormData.map(function (previousKeyedFormDatum, index) {
       return {
         key: previousKeyedFormDatum.key,
         item: nextFormData[index]
@@ -258,20 +341,15 @@ class ArrayField extends React.Component {
   }
   /** Returns the appropriate title for an item by getting first the title from the schema.items, then falling back to
    * the description from the schema.items, and finally the string "Item"
-   */
-  get itemTitle() {
-    const {
-      schema
-    } = this.props;
-    return get__default["default"](schema, [utils.ITEMS_KEY, "title"], get__default["default"](schema, [utils.ITEMS_KEY, "description"], "Item"));
-  }
+   */;
+  var _proto = ArrayField.prototype;
   /** Determines whether the item described in the schema is always required, which is determined by whether any item
    * may be null.
    *
    * @param itemSchema - The schema for the item
    * @return - True if the item schema type does not contain the "null" type
    */
-  isItemRequired(itemSchema) {
+  _proto.isItemRequired = function isItemRequired(itemSchema) {
     if (Array.isArray(itemSchema.type)) {
       // While we don't yet support composite/nullable jsonschema types, it's
       // future-proof to check for requirement against these.
@@ -286,15 +364,13 @@ class ArrayField extends React.Component {
    *
    * @param formItems - The list of items in the form
    * @returns - True if the item is addable otherwise false
-   */
-  canAddItem(formItems) {
-    const {
-      schema,
-      uiSchema
-    } = this.props;
-    let {
-      addable
-    } = utils.getUiOptions(uiSchema);
+   */;
+  _proto.canAddItem = function canAddItem(formItems) {
+    var _this$props6 = this.props,
+      schema = _this$props6.schema,
+      uiSchema = _this$props6.uiSchema;
+    var _getUiOptions = utils.getUiOptions(uiSchema),
+      addable = _getUiOptions.addable;
     if (addable !== false) {
       // if ui:options.addable was not explicitly set to false, we can add
       // another item if we have not exceeded maxItems yet
@@ -308,23 +384,19 @@ class ArrayField extends React.Component {
   }
   /** Returns the default form information for an item based on the schema for that item. Deals with the possibility
    * that the schema is fixed and allows additional items.
-   */
-
+   */;
   /** Renders the `ArrayField` depending on the specific needs of the schema and uischema elements
    */
-  render() {
-    const {
-      schema,
-      uiSchema,
-      idSchema,
-      registry
-    } = this.props;
-    const {
-      schemaUtils
-    } = registry;
+  _proto.render = function render() {
+    var _this$props7 = this.props,
+      schema = _this$props7.schema,
+      uiSchema = _this$props7.uiSchema,
+      idSchema = _this$props7.idSchema,
+      registry = _this$props7.registry;
+    var schemaUtils = registry.schemaUtils;
     if (!(utils.ITEMS_KEY in schema)) {
-      const uiOptions = utils.getUiOptions(uiSchema);
-      const UnsupportedFieldTemplate = utils.getTemplate("UnsupportedFieldTemplate", registry, uiOptions);
+      var uiOptions = utils.getUiOptions(uiSchema);
+      var UnsupportedFieldTemplate = utils.getTemplate("UnsupportedFieldTemplate", registry, uiOptions);
       return /*#__PURE__*/React__default["default"].createElement(UnsupportedFieldTemplate, {
         schema: schema,
         idSchema: idSchema,
@@ -348,116 +420,115 @@ class ArrayField extends React.Component {
     return this.renderNormalArray();
   }
   /** Renders a normal array without any limitations of length
-   */
-  renderNormalArray() {
-    const {
-      schema,
-      uiSchema = {},
-      errorSchema,
-      idSchema,
-      name,
-      disabled = false,
-      readonly = false,
-      autofocus = false,
-      required = false,
-      registry,
-      onBlur,
-      onFocus,
-      idPrefix,
-      idSeparator = "_",
-      rawErrors
-    } = this.props;
-    const {
-      keyedFormData
-    } = this.state;
-    const title = schema.title === undefined ? name : schema.title;
-    const {
-      schemaUtils,
-      formContext
-    } = registry;
-    const uiOptions = utils.getUiOptions(uiSchema);
-    const _schemaItems = isObject__default["default"](schema.items) ? schema.items : {};
-    const itemsSchema = schemaUtils.retrieveSchema(_schemaItems);
-    const formData = keyedToPlainFormData(this.state.keyedFormData);
-    const arrayProps = {
+   */;
+  _proto.renderNormalArray = function renderNormalArray() {
+    var _this2 = this;
+    var _this$props8 = this.props,
+      schema = _this$props8.schema,
+      _this$props8$uiSchema = _this$props8.uiSchema,
+      uiSchema = _this$props8$uiSchema === void 0 ? {} : _this$props8$uiSchema,
+      errorSchema = _this$props8.errorSchema,
+      idSchema = _this$props8.idSchema,
+      name = _this$props8.name,
+      _this$props8$disabled = _this$props8.disabled,
+      disabled = _this$props8$disabled === void 0 ? false : _this$props8$disabled,
+      _this$props8$readonly = _this$props8.readonly,
+      readonly = _this$props8$readonly === void 0 ? false : _this$props8$readonly,
+      _this$props8$autofocu = _this$props8.autofocus,
+      autofocus = _this$props8$autofocu === void 0 ? false : _this$props8$autofocu,
+      _this$props8$required = _this$props8.required,
+      required = _this$props8$required === void 0 ? false : _this$props8$required,
+      registry = _this$props8.registry,
+      onBlur = _this$props8.onBlur,
+      onFocus = _this$props8.onFocus,
+      idPrefix = _this$props8.idPrefix,
+      _this$props8$idSepara = _this$props8.idSeparator,
+      idSeparator = _this$props8$idSepara === void 0 ? "_" : _this$props8$idSepara,
+      rawErrors = _this$props8.rawErrors;
+    var keyedFormData = this.state.keyedFormData;
+    var title = schema.title === undefined ? name : schema.title;
+    var schemaUtils = registry.schemaUtils,
+      formContext = registry.formContext;
+    var uiOptions = utils.getUiOptions(uiSchema);
+    var _schemaItems = isObject__default["default"](schema.items) ? schema.items : {};
+    var itemsSchema = schemaUtils.retrieveSchema(_schemaItems);
+    var formData = keyedToPlainFormData(this.state.keyedFormData);
+    var arrayProps = {
       canAdd: this.canAddItem(formData),
-      items: keyedFormData.map((keyedItem, index) => {
-        const {
-          key,
-          item
-        } = keyedItem;
+      items: keyedFormData.map(function (keyedItem, index) {
+        var key = keyedItem.key,
+          item = keyedItem.item;
         // While we are actually dealing with a single item of type T, the types require a T[], so cast
-        const itemCast = item;
-        const itemSchema = schemaUtils.retrieveSchema(_schemaItems, itemCast);
-        const itemErrorSchema = errorSchema ? errorSchema[index] : undefined;
-        const itemIdPrefix = idSchema.$id + idSeparator + index;
-        const itemIdSchema = schemaUtils.toIdSchema(itemSchema, itemIdPrefix, itemCast, idPrefix, idSeparator);
-        return this.renderArrayFieldItem({
-          key,
-          index,
-          name: name && `${name}-${index}`,
+        var itemCast = item;
+        var itemSchema = schemaUtils.retrieveSchema(_schemaItems, itemCast);
+        var itemErrorSchema = errorSchema ? errorSchema[index] : undefined;
+        var itemIdPrefix = idSchema.$id + idSeparator + index;
+        var itemIdSchema = schemaUtils.toIdSchema(itemSchema, itemIdPrefix, itemCast, idPrefix, idSeparator);
+        return _this2.renderArrayFieldItem({
+          key: key,
+          index: index,
+          name: name && name + "-" + index,
           canMoveUp: index > 0,
           canMoveDown: index < formData.length - 1,
-          itemSchema,
-          itemIdSchema,
-          itemErrorSchema,
+          itemSchema: itemSchema,
+          itemIdSchema: itemIdSchema,
+          itemErrorSchema: itemErrorSchema,
           itemData: itemCast,
           itemUiSchema: uiSchema.items,
           autofocus: autofocus && index === 0,
-          onBlur,
-          onFocus,
-          rawErrors
+          onBlur: onBlur,
+          onFocus: onFocus,
+          rawErrors: rawErrors
         });
       }),
-      className: `field field-array field-array-of-${itemsSchema.type}`,
-      disabled,
-      idSchema,
-      uiSchema,
+      className: "field field-array field-array-of-" + itemsSchema.type,
+      disabled: disabled,
+      idSchema: idSchema,
+      uiSchema: uiSchema,
       onAddClick: this.onAddClick,
-      readonly,
-      required,
-      schema,
-      title,
-      formContext,
-      formData,
-      rawErrors,
-      registry
+      readonly: readonly,
+      required: required,
+      schema: schema,
+      title: title,
+      formContext: formContext,
+      formData: formData,
+      rawErrors: rawErrors,
+      registry: registry
     };
-    const Template = utils.getTemplate("ArrayFieldTemplate", registry, uiOptions);
-    return /*#__PURE__*/React__default["default"].createElement(Template, {
-      ...arrayProps
-    });
+    var Template = utils.getTemplate("ArrayFieldTemplate", registry, uiOptions);
+    return /*#__PURE__*/React__default["default"].createElement(Template, _extends({}, arrayProps));
   }
   /** Renders an array using the custom widget provided by the user in the `uiSchema`
-   */
-  renderCustomWidget() {
-    const {
-      schema,
-      idSchema,
-      uiSchema,
-      disabled = false,
-      readonly = false,
-      autofocus = false,
-      required = false,
-      hideError,
-      placeholder,
-      onBlur,
-      onFocus,
-      formData: items = [],
-      registry,
-      rawErrors,
-      name
-    } = this.props;
-    const {
-      widgets,
-      formContext
-    } = registry;
-    const title = schema.title || name;
-    const {
-      widget,
-      ...options
-    } = utils.getUiOptions(uiSchema);
-    const Widget = utils.getWidget(schema, widget, widgets);
+   */;
+  _proto.renderCustomWidget = function renderCustomWidget() {
+    var _this$props9 = this.props,
+      schema = _this$props9.schema,
+      idSchema = _this$props9.idSchema,
+      uiSchema = _this$props9.uiSchema,
+      _this$props9$disabled = _this$props9.disabled,
+      disabled = _this$props9$disabled === void 0 ? false : _this$props9$disabled,
+      _this$props9$readonly = _this$props9.readonly,
+      readonly = _this$props9$readonly === void 0 ? false : _this$props9$readonly,
+      _this$props9$autofocu = _this$props9.autofocus,
+      autofocus = _this$props9$autofocu === void 0 ? false : _this$props9$autofocu,
+      _this$props9$required = _this$props9.required,
+      required = _this$props9$required === void 0 ? false : _this$props9$required,
+      hideError = _this$props9.hideError,
+      placeholder = _this$props9.placeholder,
+      onBlur = _this$props9.onBlur,
+      onFocus = _this$props9.onFocus,
+      _this$props9$formData = _this$props9.formData,
+      items = _this$props9$formData === void 0 ? [] : _this$props9$formData,
+      registry = _this$props9.registry,
+      rawErrors = _this$props9.rawErrors,
+      name = _this$props9.name;
+    var widgets = registry.widgets,
+      formContext = registry.formContext;
+    var title = schema.title || name;
+    var _getUiOptions2 = utils.getUiOptions(uiSchema),
+      widget = _getUiOptions2.widget,
+      options = _objectWithoutPropertiesLoose(_getUiOptions2, _excluded$9);
+    var Widget = utils.getWidget(schema, widget, widgets);
     return /*#__PURE__*/React__default["default"].createElement(Widget, {
       id: idSchema && idSchema.$id,
       multiple: true,
@@ -481,47 +552,48 @@ class ArrayField extends React.Component {
     });
   }
   /** Renders an array as a set of checkboxes
-   */
-  renderMultiSelect() {
-    const {
-      schema,
-      idSchema,
-      uiSchema,
-      formData: items = [],
-      disabled = false,
-      readonly = false,
-      autofocus = false,
-      required = false,
-      placeholder,
-      onBlur,
-      onFocus,
-      registry,
-      rawErrors,
-      name
-    } = this.props;
-    const {
-      widgets,
-      schemaUtils,
-      formContext
-    } = registry;
-    const itemsSchema = schemaUtils.retrieveSchema(schema.items, items);
-    const title = schema.title || name;
-    const enumOptions = utils.optionsList(itemsSchema);
-    const {
-      widget = "select",
-      ...options
-    } = utils.getUiOptions(uiSchema);
-    const Widget = utils.getWidget(schema, widget, widgets);
+   */;
+  _proto.renderMultiSelect = function renderMultiSelect() {
+    var _this$props10 = this.props,
+      schema = _this$props10.schema,
+      idSchema = _this$props10.idSchema,
+      uiSchema = _this$props10.uiSchema,
+      _this$props10$formDat = _this$props10.formData,
+      items = _this$props10$formDat === void 0 ? [] : _this$props10$formDat,
+      _this$props10$disable = _this$props10.disabled,
+      disabled = _this$props10$disable === void 0 ? false : _this$props10$disable,
+      _this$props10$readonl = _this$props10.readonly,
+      readonly = _this$props10$readonl === void 0 ? false : _this$props10$readonl,
+      _this$props10$autofoc = _this$props10.autofocus,
+      autofocus = _this$props10$autofoc === void 0 ? false : _this$props10$autofoc,
+      _this$props10$require = _this$props10.required,
+      required = _this$props10$require === void 0 ? false : _this$props10$require,
+      placeholder = _this$props10.placeholder,
+      onBlur = _this$props10.onBlur,
+      onFocus = _this$props10.onFocus,
+      registry = _this$props10.registry,
+      rawErrors = _this$props10.rawErrors,
+      name = _this$props10.name;
+    var widgets = registry.widgets,
+      schemaUtils = registry.schemaUtils,
+      formContext = registry.formContext;
+    var itemsSchema = schemaUtils.retrieveSchema(schema.items, items);
+    var title = schema.title || name;
+    var enumOptions = utils.optionsList(itemsSchema);
+    var _getUiOptions3 = utils.getUiOptions(uiSchema),
+      _getUiOptions3$widget = _getUiOptions3.widget,
+      widget = _getUiOptions3$widget === void 0 ? "select" : _getUiOptions3$widget,
+      options = _objectWithoutPropertiesLoose(_getUiOptions3, _excluded2);
+    var Widget = utils.getWidget(schema, widget, widgets);
     return /*#__PURE__*/React__default["default"].createElement(Widget, {
       id: idSchema && idSchema.$id,
       multiple: true,
       onChange: this.onSelectChange,
       onBlur: onBlur,
       onFocus: onFocus,
-      options: {
-        ...options,
-        enumOptions
-      },
+      options: _extends({}, options, {
+        enumOptions: enumOptions
+      }),
       schema: schema,
       uiSchema: uiSchema,
       registry: registry,
@@ -537,33 +609,35 @@ class ArrayField extends React.Component {
     });
   }
   /** Renders an array of files using the `FileWidget`
-   */
-  renderFiles() {
-    const {
-      schema,
-      uiSchema,
-      idSchema,
-      name,
-      disabled = false,
-      readonly = false,
-      autofocus = false,
-      required = false,
-      onBlur,
-      onFocus,
-      registry,
-      formData: items = [],
-      rawErrors
-    } = this.props;
-    const title = schema.title || name;
-    const {
-      widgets,
-      formContext
-    } = registry;
-    const {
-      widget = "files",
-      ...options
-    } = utils.getUiOptions(uiSchema);
-    const Widget = utils.getWidget(schema, widget, widgets);
+   */;
+  _proto.renderFiles = function renderFiles() {
+    var _this$props11 = this.props,
+      schema = _this$props11.schema,
+      uiSchema = _this$props11.uiSchema,
+      idSchema = _this$props11.idSchema,
+      name = _this$props11.name,
+      _this$props11$disable = _this$props11.disabled,
+      disabled = _this$props11$disable === void 0 ? false : _this$props11$disable,
+      _this$props11$readonl = _this$props11.readonly,
+      readonly = _this$props11$readonl === void 0 ? false : _this$props11$readonl,
+      _this$props11$autofoc = _this$props11.autofocus,
+      autofocus = _this$props11$autofoc === void 0 ? false : _this$props11$autofoc,
+      _this$props11$require = _this$props11.required,
+      required = _this$props11$require === void 0 ? false : _this$props11$require,
+      onBlur = _this$props11.onBlur,
+      onFocus = _this$props11.onFocus,
+      registry = _this$props11.registry,
+      _this$props11$formDat = _this$props11.formData,
+      items = _this$props11$formDat === void 0 ? [] : _this$props11$formDat,
+      rawErrors = _this$props11.rawErrors;
+    var title = schema.title || name;
+    var widgets = registry.widgets,
+      formContext = registry.formContext;
+    var _getUiOptions4 = utils.getUiOptions(uiSchema),
+      _getUiOptions4$widget = _getUiOptions4.widget,
+      widget = _getUiOptions4$widget === void 0 ? "files" : _getUiOptions4$widget,
+      options = _objectWithoutPropertiesLoose(_getUiOptions4, _excluded3);
+    var Widget = utils.getWidget(schema, widget, widgets);
     return /*#__PURE__*/React__default["default"].createElement(Widget, {
       options: options,
       id: idSchema && idSchema.$id,
@@ -586,150 +660,150 @@ class ArrayField extends React.Component {
     });
   }
   /** Renders an array that has a maximum limit of items
-   */
-  renderFixedArray() {
-    const {
-      schema,
-      uiSchema = {},
-      formData = [],
-      errorSchema,
-      idPrefix,
-      idSeparator = "_",
-      idSchema,
-      name,
-      disabled = false,
-      readonly = false,
-      autofocus = false,
-      required = false,
-      registry,
-      onBlur,
-      onFocus,
-      rawErrors
-    } = this.props;
-    const {
-      keyedFormData
-    } = this.state;
-    let {
-      formData: items = []
-    } = this.props;
-    const title = schema.title || name;
-    const uiOptions = utils.getUiOptions(uiSchema);
-    const {
-      schemaUtils,
-      formContext
-    } = registry;
-    const _schemaItems = isObject__default["default"](schema.items) ? schema.items : [];
-    const itemSchemas = _schemaItems.map((item, index) => schemaUtils.retrieveSchema(item, formData[index]));
-    const additionalSchema = isObject__default["default"](schema.additionalItems) ? schemaUtils.retrieveSchema(schema.additionalItems, formData) : null;
+   */;
+  _proto.renderFixedArray = function renderFixedArray() {
+    var _this3 = this;
+    var _this$props12 = this.props,
+      schema = _this$props12.schema,
+      _this$props12$uiSchem = _this$props12.uiSchema,
+      uiSchema = _this$props12$uiSchem === void 0 ? {} : _this$props12$uiSchem,
+      _this$props12$formDat = _this$props12.formData,
+      formData = _this$props12$formDat === void 0 ? [] : _this$props12$formDat,
+      errorSchema = _this$props12.errorSchema,
+      idPrefix = _this$props12.idPrefix,
+      _this$props12$idSepar = _this$props12.idSeparator,
+      idSeparator = _this$props12$idSepar === void 0 ? "_" : _this$props12$idSepar,
+      idSchema = _this$props12.idSchema,
+      name = _this$props12.name,
+      _this$props12$disable = _this$props12.disabled,
+      disabled = _this$props12$disable === void 0 ? false : _this$props12$disable,
+      _this$props12$readonl = _this$props12.readonly,
+      readonly = _this$props12$readonl === void 0 ? false : _this$props12$readonl,
+      _this$props12$autofoc = _this$props12.autofocus,
+      autofocus = _this$props12$autofoc === void 0 ? false : _this$props12$autofoc,
+      _this$props12$require = _this$props12.required,
+      required = _this$props12$require === void 0 ? false : _this$props12$require,
+      registry = _this$props12.registry,
+      onBlur = _this$props12.onBlur,
+      onFocus = _this$props12.onFocus,
+      rawErrors = _this$props12.rawErrors;
+    var keyedFormData = this.state.keyedFormData;
+    var _this$props$formData = this.props.formData,
+      items = _this$props$formData === void 0 ? [] : _this$props$formData;
+    var title = schema.title || name;
+    var uiOptions = utils.getUiOptions(uiSchema);
+    var schemaUtils = registry.schemaUtils,
+      formContext = registry.formContext;
+    var _schemaItems = isObject__default["default"](schema.items) ? schema.items : [];
+    var itemSchemas = _schemaItems.map(function (item, index) {
+      return schemaUtils.retrieveSchema(item, formData[index]);
+    });
+    var additionalSchema = isObject__default["default"](schema.additionalItems) ? schemaUtils.retrieveSchema(schema.additionalItems, formData) : null;
     if (!items || items.length < itemSchemas.length) {
       // to make sure at least all fixed items are generated
       items = items || [];
       items = items.concat(new Array(itemSchemas.length - items.length));
     }
     // These are the props passed into the render function
-    const arrayProps = {
+    var arrayProps = {
       canAdd: this.canAddItem(items) && !!additionalSchema,
       className: "field field-array field-array-fixed-items",
-      disabled,
-      idSchema,
-      formData,
-      items: keyedFormData.map((keyedItem, index) => {
-        const {
-          key,
-          item
-        } = keyedItem;
+      disabled: disabled,
+      idSchema: idSchema,
+      formData: formData,
+      items: keyedFormData.map(function (keyedItem, index) {
+        var key = keyedItem.key,
+          item = keyedItem.item;
         // While we are actually dealing with a single item of type T, the types require a T[], so cast
-        const itemCast = item;
-        const additional = index >= itemSchemas.length;
-        const itemSchema = additional && isObject__default["default"](schema.additionalItems) ? schemaUtils.retrieveSchema(schema.additionalItems, itemCast) : itemSchemas[index];
-        const itemIdPrefix = idSchema.$id + idSeparator + index;
-        const itemIdSchema = schemaUtils.toIdSchema(itemSchema, itemIdPrefix, itemCast, idPrefix, idSeparator);
-        const itemUiSchema = additional ? uiSchema.additionalItems || {} : Array.isArray(uiSchema.items) ? uiSchema.items[index] : uiSchema.items || {};
-        const itemErrorSchema = errorSchema ? errorSchema[index] : undefined;
-        return this.renderArrayFieldItem({
-          key,
-          index,
-          name: name && `${name}-${index}`,
+        var itemCast = item;
+        var additional = index >= itemSchemas.length;
+        var itemSchema = additional && isObject__default["default"](schema.additionalItems) ? schemaUtils.retrieveSchema(schema.additionalItems, itemCast) : itemSchemas[index];
+        var itemIdPrefix = idSchema.$id + idSeparator + index;
+        var itemIdSchema = schemaUtils.toIdSchema(itemSchema, itemIdPrefix, itemCast, idPrefix, idSeparator);
+        var itemUiSchema = additional ? uiSchema.additionalItems || {} : Array.isArray(uiSchema.items) ? uiSchema.items[index] : uiSchema.items || {};
+        var itemErrorSchema = errorSchema ? errorSchema[index] : undefined;
+        return _this3.renderArrayFieldItem({
+          key: key,
+          index: index,
+          name: name && name + "-" + index,
           canRemove: additional,
           canMoveUp: index >= itemSchemas.length + 1,
           canMoveDown: additional && index < items.length - 1,
-          itemSchema,
+          itemSchema: itemSchema,
           itemData: itemCast,
-          itemUiSchema,
-          itemIdSchema,
-          itemErrorSchema,
+          itemUiSchema: itemUiSchema,
+          itemIdSchema: itemIdSchema,
+          itemErrorSchema: itemErrorSchema,
           autofocus: autofocus && index === 0,
-          onBlur,
-          onFocus,
-          rawErrors
+          onBlur: onBlur,
+          onFocus: onFocus,
+          rawErrors: rawErrors
         });
       }),
       onAddClick: this.onAddClick,
-      readonly,
-      required,
-      registry,
-      schema,
-      uiSchema,
-      title,
-      formContext,
-      rawErrors
+      readonly: readonly,
+      required: required,
+      registry: registry,
+      schema: schema,
+      uiSchema: uiSchema,
+      title: title,
+      formContext: formContext,
+      rawErrors: rawErrors
     };
-    const Template = utils.getTemplate("ArrayFieldTemplate", registry, uiOptions);
-    return /*#__PURE__*/React__default["default"].createElement(Template, {
-      ...arrayProps
-    });
+    var Template = utils.getTemplate("ArrayFieldTemplate", registry, uiOptions);
+    return /*#__PURE__*/React__default["default"].createElement(Template, _extends({}, arrayProps));
   }
   /** Renders the individual array item using a `SchemaField` along with the additional properties required to be send
    * back to the `ArrayFieldItemTemplate`.
    *
    * @param props - The props for the individual array item to be rendered
-   */
-  renderArrayFieldItem(props) {
-    const {
-      key,
-      index,
-      name,
-      canRemove = true,
-      canMoveUp = true,
-      canMoveDown = true,
-      itemSchema,
-      itemData,
-      itemUiSchema,
-      itemIdSchema,
-      itemErrorSchema,
-      autofocus,
-      onBlur,
-      onFocus,
-      rawErrors
-    } = props;
-    const {
-      disabled,
-      hideError,
-      idPrefix,
-      idSeparator,
-      readonly,
-      uiSchema,
-      registry,
-      formContext
-    } = this.props;
-    const {
-      fields: {
-        ArraySchemaField,
-        SchemaField
-      }
-    } = registry;
-    const ItemSchemaField = ArraySchemaField || SchemaField;
-    const {
-      orderable = true,
-      removable = true
-    } = utils.getUiOptions(uiSchema);
-    const has = {
+   */;
+  _proto.renderArrayFieldItem = function renderArrayFieldItem(props) {
+    var key = props.key,
+      index = props.index,
+      name = props.name,
+      _props$canRemove = props.canRemove,
+      canRemove = _props$canRemove === void 0 ? true : _props$canRemove,
+      _props$canMoveUp = props.canMoveUp,
+      canMoveUp = _props$canMoveUp === void 0 ? true : _props$canMoveUp,
+      _props$canMoveDown = props.canMoveDown,
+      canMoveDown = _props$canMoveDown === void 0 ? true : _props$canMoveDown,
+      itemSchema = props.itemSchema,
+      itemData = props.itemData,
+      itemUiSchema = props.itemUiSchema,
+      itemIdSchema = props.itemIdSchema,
+      itemErrorSchema = props.itemErrorSchema,
+      autofocus = props.autofocus,
+      onBlur = props.onBlur,
+      onFocus = props.onFocus,
+      rawErrors = props.rawErrors;
+    var _this$props13 = this.props,
+      disabled = _this$props13.disabled,
+      hideError = _this$props13.hideError,
+      idPrefix = _this$props13.idPrefix,
+      idSeparator = _this$props13.idSeparator,
+      readonly = _this$props13.readonly,
+      uiSchema = _this$props13.uiSchema,
+      registry = _this$props13.registry,
+      formContext = _this$props13.formContext;
+    var _registry$fields = registry.fields,
+      ArraySchemaField = _registry$fields.ArraySchemaField,
+      SchemaField = _registry$fields.SchemaField;
+    var ItemSchemaField = ArraySchemaField || SchemaField;
+    var _getUiOptions5 = utils.getUiOptions(uiSchema),
+      _getUiOptions5$ordera = _getUiOptions5.orderable,
+      orderable = _getUiOptions5$ordera === void 0 ? true : _getUiOptions5$ordera,
+      _getUiOptions5$remova = _getUiOptions5.removable,
+      removable = _getUiOptions5$remova === void 0 ? true : _getUiOptions5$remova;
+    var has = {
       moveUp: orderable && canMoveUp,
       moveDown: orderable && canMoveDown,
       remove: removable && canRemove,
       toolbar: false
     };
-    has.toolbar = Object.keys(has).some(key => has[key]);
+    has.toolbar = Object.keys(has).some(function (key) {
+      return has[key];
+    });
     return {
       children: /*#__PURE__*/React__default["default"].createElement(ItemSchemaField, {
         name: name,
@@ -754,75 +828,83 @@ class ArrayField extends React.Component {
         rawErrors: rawErrors
       }),
       className: "array-item",
-      disabled,
+      disabled: disabled,
       hasToolbar: has.toolbar,
       hasMoveUp: has.moveUp,
       hasMoveDown: has.moveDown,
       hasRemove: has.remove,
-      index,
-      key,
+      index: index,
+      key: key,
       onAddIndexClick: this.onAddIndexClick,
       onDropIndexClick: this.onDropIndexClick,
       onReorderClick: this.onReorderClick,
-      readonly,
-      registry,
+      readonly: readonly,
+      registry: registry,
+      schema: itemSchema,
       uiSchema: itemUiSchema
     };
-  }
-}
+  };
+  _createClass(ArrayField, [{
+    key: "itemTitle",
+    get: function get() {
+      var schema = this.props.schema;
+      return get__default["default"](schema, [utils.ITEMS_KEY, "title"], get__default["default"](schema, [utils.ITEMS_KEY, "description"], "Item"));
+    }
+  }]);
+  return ArrayField;
+}(React.Component);
 
+var _excluded$8 = ["widget"];
 /** The `BooleanField` component is used to render a field in the schema is boolean. It constructs `enumOptions` for the
  * two boolean values based on the various alternatives in the schema.
  *
  * @param props - The `FieldProps` for this template
  */
 function BooleanField(props) {
-  const {
-    schema,
-    name,
-    uiSchema,
-    idSchema,
-    formData,
-    registry,
-    required,
-    disabled,
-    readonly,
-    autofocus,
-    onChange,
-    onFocus,
-    onBlur,
-    rawErrors
-  } = props;
-  const {
-    title
-  } = schema;
-  const {
-    widgets,
-    formContext
-  } = registry;
-  const {
-    widget = "checkbox",
-    ...options
-  } = utils.getUiOptions(uiSchema);
-  const Widget = utils.getWidget(schema, widget, widgets);
-  let enumOptions;
+  var schema = props.schema,
+    name = props.name,
+    uiSchema = props.uiSchema,
+    idSchema = props.idSchema,
+    formData = props.formData,
+    registry = props.registry,
+    required = props.required,
+    disabled = props.disabled,
+    readonly = props.readonly,
+    autofocus = props.autofocus,
+    onChange = props.onChange,
+    onFocus = props.onFocus,
+    onBlur = props.onBlur,
+    rawErrors = props.rawErrors;
+  var title = schema.title;
+  var widgets = registry.widgets,
+    formContext = registry.formContext;
+  var _getUiOptions = utils.getUiOptions(uiSchema),
+    _getUiOptions$widget = _getUiOptions.widget,
+    widget = _getUiOptions$widget === void 0 ? "checkbox" : _getUiOptions$widget,
+    options = _objectWithoutPropertiesLoose(_getUiOptions, _excluded$8);
+  var Widget = utils.getWidget(schema, widget, widgets);
+  var enumOptions;
   if (Array.isArray(schema.oneOf)) {
     enumOptions = utils.optionsList({
-      oneOf: schema.oneOf.map(option => {
+      oneOf: schema.oneOf.map(function (option) {
         if (isObject__default["default"](option)) {
-          return {
-            ...option,
-            title: option.title || (option.const === true ? "Yes" : "No")
-          };
+          return _extends({}, option, {
+            title: option.title || (option["const"] === true ? "Yes" : "No")
+          });
         }
         return undefined;
-      }).filter(o => o) // cast away the error that typescript can't grok is fixed
+      }).filter(function (o) {
+        return o;
+      }) // cast away the error that typescript can't grok is fixed
     });
   } else {
+    var _schema$enum;
     // We deprecated enumNames in v5. It's intentionally omitted from RSJFSchema type, so we need to cast here.
-    const schemaWithEnumNames = schema;
-    const enums = schema.enum ?? [true, false];
-    if (!schemaWithEnumNames.enumNames && enums.length === 2 && enums.every(v => typeof v === "boolean")) {
+    var schemaWithEnumNames = schema;
+    var enums = (_schema$enum = schema["enum"]) != null ? _schema$enum : [true, false];
+    if (!schemaWithEnumNames.enumNames && enums.length === 2 && enums.every(function (v) {
+      return typeof v === "boolean";
+    })) {
       enumOptions = [{
         value: enums[0],
         label: enums[0] ? "Yes" : "No"
@@ -832,17 +914,16 @@ function BooleanField(props) {
       }];
     } else {
       enumOptions = utils.optionsList({
-        enum: enums,
+        "enum": enums,
         // NOTE: enumNames is deprecated, but still supported for now.
         enumNames: schemaWithEnumNames.enumNames
       });
     }
   }
   return /*#__PURE__*/React__default["default"].createElement(Widget, {
-    options: {
-      ...options,
-      enumOptions
-    },
+    options: _extends({}, options, {
+      enumOptions: enumOptions
+    }),
     schema: schema,
     uiSchema: uiSchema,
     id: idSchema && idSchema.$id,
@@ -861,41 +942,42 @@ function BooleanField(props) {
   });
 }
 
+var _excluded$7 = ["widget"];
 /** The `AnyOfField` component is used to render a field in the schema that is an `anyOf`, `allOf` or `oneOf`. It tracks
  * the currently selected option and cleans up any irrelevant data in `formData`.
  *
  * @param props - The `FieldProps` for this template
  */
-class AnyOfField extends React.Component {
+var AnyOfField = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(AnyOfField, _Component);
   /** Constructs an `AnyOfField` with the given `props` to initialize the initially selected option in state
    *
    * @param props - The `FieldProps` for this template
    */
-  constructor(props) {
-    super(props);
-    this.onOptionChange = option => {
-      const selectedOption = parseInt(option, 10);
-      const {
-        formData,
-        onChange,
-        options,
-        registry
-      } = this.props;
-      const {
-        schemaUtils
-      } = registry;
-      const newOption = schemaUtils.retrieveSchema(options[selectedOption], formData);
+  function AnyOfField(props) {
+    var _this;
+    _this = _Component.call(this, props) || this;
+    _this.onOptionChange = function (option) {
+      var selectedOption = parseInt(option, 10);
+      var _this$props = _this.props,
+        formData = _this$props.formData,
+        onChange = _this$props.onChange,
+        options = _this$props.options,
+        registry = _this$props.registry;
+      var schemaUtils = registry.schemaUtils;
+      var newOption = schemaUtils.retrieveSchema(options[selectedOption], formData);
       // If the new option is of type object and the current data is an object,
       // discard properties added using the old option.
-      let newFormData = undefined;
+      var newFormData = undefined;
       if (utils.guessType(formData) === "object" && (newOption.type === "object" || newOption.properties)) {
         newFormData = Object.assign({}, formData);
-        const optionsToDiscard = options.slice();
+        var optionsToDiscard = options.slice();
         optionsToDiscard.splice(selectedOption, 1);
         // Discard any data added using other options
-        for (const option of optionsToDiscard) {
-          if (option.properties) {
-            for (const key in option.properties) {
+        for (var _iterator = _createForOfIteratorHelperLoose(optionsToDiscard), _step; !(_step = _iterator()).done;) {
+          var _option = _step.value;
+          if (_option.properties) {
+            for (var key in _option.properties) {
               if (key in newFormData) {
                 unset__default["default"](newFormData, key);
               }
@@ -905,18 +987,18 @@ class AnyOfField extends React.Component {
       }
       // Call getDefaultFormState to make sure defaults are populated on change. Pass "excludeObjectChildren"
       // so that only the root objects themselves are created without adding undefined children properties
-      onChange(schemaUtils.getDefaultFormState(options[selectedOption], newFormData, "excludeObjectChildren"), undefined, this.getFieldId());
-      this.setState({
+      onChange(schemaUtils.getDefaultFormState(options[selectedOption], newFormData, "excludeObjectChildren"), undefined, _this.getFieldId());
+      _this.setState({
         selectedOption: parseInt(option, 10)
       });
     };
-    const {
-      formData: _formData,
-      options: _options
-    } = this.props;
-    this.state = {
-      selectedOption: this.getMatchingOption(0, _formData, _options)
+    var _this$props2 = _this.props,
+      _formData = _this$props2.formData,
+      _options = _this$props2.options;
+    _this.state = {
+      selectedOption: _this.getMatchingOption(0, _formData, _options)
     };
+    return _this;
   }
   /** React lifecycle methos that is called when the props and/or state for this component is updated. It recomputes the
    * currently selected option based on the overall `formData`
@@ -924,17 +1006,15 @@ class AnyOfField extends React.Component {
    * @param prevProps - The previous `FieldProps` for this template
    * @param prevState - The previous `AnyOfFieldState` for this template
    */
-  componentDidUpdate(prevProps, prevState) {
-    const {
-      formData,
-      options,
-      idSchema
-    } = this.props;
-    const {
-      selectedOption
-    } = this.state;
+  var _proto = AnyOfField.prototype;
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
+    var _this$props3 = this.props,
+      formData = _this$props3.formData,
+      options = _this$props3.options,
+      idSchema = _this$props3.idSchema;
+    var selectedOption = this.state.selectedOption;
     if (!utils.deepEquals(formData, prevProps.formData) && idSchema.$id === prevProps.idSchema.$id) {
-      const matchingOption = this.getMatchingOption(selectedOption, formData, options);
+      var matchingOption = this.getMatchingOption(selectedOption, formData, options);
       if (!prevState || matchingOption === selectedOption) {
         return;
       }
@@ -948,12 +1028,10 @@ class AnyOfField extends React.Component {
    * @param formData - The new formData
    * @param options - The list of options to choose from
    * @return - The index of the `option` that best matches the `formData`
-   */
-  getMatchingOption(selectedOption, formData, options) {
-    const {
-      schemaUtils
-    } = this.props.registry;
-    const option = schemaUtils.getMatchingOption(formData, options);
+   */;
+  _proto.getMatchingOption = function getMatchingOption(selectedOption, formData, options) {
+    var schemaUtils = this.props.registry.schemaUtils;
+    var option = schemaUtils.getMatchingOption(formData, options);
     if (option !== 0) {
       return option;
     }
@@ -966,56 +1044,51 @@ class AnyOfField extends React.Component {
    * the `onChange` handler.
    *
    * @param option -
-   */
-
-  getFieldId() {
-    const {
-      idSchema,
-      schema
-    } = this.props;
-    return `${idSchema.$id}${schema.oneOf ? "__oneof_select" : "__anyof_select"}`;
+   */;
+  _proto.getFieldId = function getFieldId() {
+    var _this$props4 = this.props,
+      idSchema = _this$props4.idSchema,
+      schema = _this$props4.schema;
+    return "" + idSchema.$id + (schema.oneOf ? "__oneof_select" : "__anyof_select");
   }
   /** Renders the `AnyOfField` selector along with a `SchemaField` for the value of the `formData`
-   */
-  render() {
-    const {
-      name,
-      baseType,
-      disabled = false,
-      readonly = false,
-      hideError = false,
-      errorSchema = {},
-      formData,
-      formContext,
-      idPrefix,
-      idSeparator,
-      idSchema,
-      onBlur,
-      onChange,
-      onFocus,
-      options,
-      registry,
-      uiSchema
-    } = this.props;
-    const {
-      widgets,
-      fields
-    } = registry;
-    const {
-      SchemaField: _SchemaField
-    } = fields;
-    const {
-      selectedOption
-    } = this.state;
-    const {
-      widget = "select",
-      ...uiOptions
-    } = utils.getUiOptions(uiSchema);
-    const Widget = utils.getWidget({
+   */;
+  _proto.render = function render() {
+    var _this$props5 = this.props,
+      name = _this$props5.name,
+      baseType = _this$props5.baseType,
+      _this$props5$disabled = _this$props5.disabled,
+      disabled = _this$props5$disabled === void 0 ? false : _this$props5$disabled,
+      _this$props5$readonly = _this$props5.readonly,
+      readonly = _this$props5$readonly === void 0 ? false : _this$props5$readonly,
+      _this$props5$hideErro = _this$props5.hideError,
+      hideError = _this$props5$hideErro === void 0 ? false : _this$props5$hideErro,
+      _this$props5$errorSch = _this$props5.errorSchema,
+      errorSchema = _this$props5$errorSch === void 0 ? {} : _this$props5$errorSch,
+      formData = _this$props5.formData,
+      formContext = _this$props5.formContext,
+      idPrefix = _this$props5.idPrefix,
+      idSeparator = _this$props5.idSeparator,
+      idSchema = _this$props5.idSchema,
+      onBlur = _this$props5.onBlur,
+      onChange = _this$props5.onChange,
+      onFocus = _this$props5.onFocus,
+      options = _this$props5.options,
+      registry = _this$props5.registry,
+      uiSchema = _this$props5.uiSchema;
+    var widgets = registry.widgets,
+      fields = registry.fields;
+    var _SchemaField = fields.SchemaField;
+    var selectedOption = this.state.selectedOption;
+    var _getUiOptions = utils.getUiOptions(uiSchema),
+      _getUiOptions$widget = _getUiOptions.widget,
+      widget = _getUiOptions$widget === void 0 ? "select" : _getUiOptions$widget,
+      uiOptions = _objectWithoutPropertiesLoose(_getUiOptions, _excluded$7);
+    var Widget = utils.getWidget({
       type: "number"
     }, widget, widgets);
-    const option = options[selectedOption] || null;
-    let optionSchema;
+    var option = options[selectedOption] || null;
+    var optionSchema;
     if (option) {
       // If the subschema doesn't declare a type, infer the type from the
       // parent schema
@@ -1023,32 +1096,34 @@ class AnyOfField extends React.Component {
         type: baseType
       });
     }
-    const enumOptions = options.map((option, index) => ({
-      label: option.title || `Option ${index + 1}`,
-      value: index
-    }));
+    var enumOptions = options.map(function (option, index) {
+      return {
+        label: option.title || "Option " + (index + 1),
+        value: index
+      };
+    });
     return /*#__PURE__*/React__default["default"].createElement("div", {
       className: "panel panel-default panel-body"
     }, /*#__PURE__*/React__default["default"].createElement("div", {
       className: "form-group"
-    }, /*#__PURE__*/React__default["default"].createElement(Widget, {
+    }, /*#__PURE__*/React__default["default"].createElement(Widget, _extends({
       id: this.getFieldId(),
       schema: {
         type: "number",
-        default: 0
+        "default": 0
       },
       onChange: this.onOptionChange,
       onBlur: onBlur,
       onFocus: onFocus,
       value: selectedOption,
       options: {
-        enumOptions
+        enumOptions: enumOptions
       },
       registry: registry,
-      formContext: formContext,
-      ...uiOptions,
+      formContext: formContext
+    }, uiOptions, {
       label: ""
-    })), option !== null && /*#__PURE__*/React__default["default"].createElement(_SchemaField, {
+    }))), option !== null && /*#__PURE__*/React__default["default"].createElement(_SchemaField, {
       name: name,
       schema: optionSchema,
       uiSchema: uiSchema,
@@ -1066,19 +1141,20 @@ class AnyOfField extends React.Component {
       readonly: readonly,
       hideError: hideError
     }));
-  }
-}
+  };
+  return AnyOfField;
+}(React.Component);
 
 // Matches a string that ends in a . character, optionally followed by a sequence of
 // digits followed by any number of 0 characters up until the end of the line.
 // Ensuring that there is at least one prefixed character is important so that
 // you don't incorrectly match against "0".
-const trailingCharMatcherWithPrefix = /\.([0-9]*0)*$/;
+var trailingCharMatcherWithPrefix = /\.([0-9]*0)*$/;
 // This is used for trimming the trailing 0 and . characters without affecting
 // the rest of the string. Its possible to use one RegEx with groups for this
 // functionality, but it is fairly complex compared to simply defining two
 // different matchers.
-const trailingCharMatcher = /[0.]0*$/;
+var trailingCharMatcher = /[0.]0*$/;
 /**
  * The NumberField class has some special handling for dealing with trailing
  * decimal points and/or zeroes. This logic is designed to allow trailing values
@@ -1097,51 +1173,48 @@ const trailingCharMatcher = /[0.]0*$/;
  *    value is passed to the input instead of the formData value
  */
 function NumberField(props) {
-  const {
-    registry,
-    onChange,
-    formData,
-    value: initialValue
-  } = props;
-  const [lastValue, setLastValue] = React.useState(initialValue);
-  const {
-    StringField
-  } = registry.fields;
-  let value = formData;
+  var registry = props.registry,
+    onChange = props.onChange,
+    formData = props.formData,
+    initialValue = props.value;
+  var _useState = React.useState(initialValue),
+    lastValue = _useState[0],
+    setLastValue = _useState[1];
+  var StringField = registry.fields.StringField;
+  var value = formData;
   /** Handle the change from the `StringField` to properly convert to a number
    *
    * @param value - The current value for the change occurring
    */
-  const handleChange = React.useCallback(value => {
+  var handleChange = React.useCallback(function (value) {
     // Cache the original value in component state
     setLastValue(value);
     // Normalize decimals that don't start with a zero character in advance so
     // that the rest of the normalization logic is simpler
-    if (`${value}`.charAt(0) === ".") {
-      value = `0${value}`;
+    if (("" + value).charAt(0) === ".") {
+      value = "0" + value;
     }
     // Check that the value is a string (this can happen if the widget used is a
     // <select>, due to an enum declaration etc) then, if the value ends in a
     // trailing decimal point or multiple zeroes, strip the trailing values
-    const processed = typeof value === "string" && value.match(trailingCharMatcherWithPrefix) ? utils.asNumber(value.replace(trailingCharMatcher, "")) : utils.asNumber(value);
+    var processed = typeof value === "string" && value.match(trailingCharMatcherWithPrefix) ? utils.asNumber(value.replace(trailingCharMatcher, "")) : utils.asNumber(value);
     onChange(processed);
   }, [onChange]);
   if (typeof lastValue === "string" && typeof value === "number") {
     // Construct a regular expression that checks for a string that consists
     // of the formData value suffixed with zero or one '.' characters and zero
     // or more '0' characters
-    const re = new RegExp(`${value}`.replace(".", "\\.") + "\\.?0*$");
+    var re = new RegExp(("" + value).replace(".", "\\.") + "\\.?0*$");
     // If the cached "lastValue" is a match, use that instead of the formData
     // value to prevent the input value from changing in the UI
     if (lastValue.match(re)) {
       value = lastValue;
     }
   }
-  return /*#__PURE__*/React__default["default"].createElement(StringField, {
-    ...props,
+  return /*#__PURE__*/React__default["default"].createElement(StringField, _extends({}, props, {
     formData: value,
     onChange: handleChange
-  });
+  }));
 }
 
 /** The `ObjectField` component is used to render a field in the schema that is of type `object`. It tracks whether an
@@ -1149,25 +1222,28 @@ function NumberField(props) {
  *
  * @param props - The `FieldProps` for this template
  */
-class ObjectField extends React.Component {
-  constructor() {
+var ObjectField = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(ObjectField, _Component);
+  function ObjectField() {
     var _this;
-    super(...arguments);
-    _this = this;
-    this.state = {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _Component.call.apply(_Component, [this].concat(args)) || this;
+    _this.state = {
       wasPropertyKeyModified: false,
       additionalProperties: {}
     };
-    this.onPropertyChange = function (name, addedByAdditionalProperties) {
+    _this.onPropertyChange = function (name, addedByAdditionalProperties) {
       if (addedByAdditionalProperties === void 0) {
         addedByAdditionalProperties = false;
       }
-      return (value, newErrorSchema, id) => {
-        const {
-          formData,
-          onChange,
-          errorSchema
-        } = _this.props;
+      return function (value, newErrorSchema, id) {
+        var _extends2, _extends3;
+        var _this$props = _this.props,
+          formData = _this$props.formData,
+          onChange = _this$props.onChange,
+          errorSchema = _this$props.errorSchema;
         if (value === undefined && addedByAdditionalProperties) {
           // Don't set value = undefined for fields added by
           // additionalProperties. Doing so removes them from the
@@ -1178,117 +1254,95 @@ class ObjectField extends React.Component {
           // set empty values to the empty string.
           value = "";
         }
-        const newFormData = {
-          ...formData,
-          [name]: value
-        };
-        onChange(newFormData, errorSchema && errorSchema && {
-          ...errorSchema,
-          [name]: newErrorSchema
-        }, id);
+        var newFormData = _extends({}, formData, (_extends2 = {}, _extends2[name] = value, _extends2));
+        onChange(newFormData, errorSchema && errorSchema && _extends({}, errorSchema, (_extends3 = {}, _extends3[name] = newErrorSchema, _extends3)), id);
       };
     };
-    this.onDropPropertyClick = key => {
-      return event => {
+    _this.onDropPropertyClick = function (key) {
+      return function (event) {
         event.preventDefault();
-        const {
-          onChange,
-          formData
-        } = this.props;
-        const copiedFormData = {
-          ...formData
-        };
+        var _this$props2 = _this.props,
+          onChange = _this$props2.onChange,
+          formData = _this$props2.formData;
+        var copiedFormData = _extends({}, formData);
         unset__default["default"](copiedFormData, key);
         onChange(copiedFormData);
       };
     };
-    this.getAvailableKey = (preferredKey, formData) => {
-      const {
-        uiSchema
-      } = this.props;
-      const {
-        duplicateKeySuffixSeparator = "-"
-      } = utils.getUiOptions(uiSchema);
-      let index = 0;
-      let newKey = preferredKey;
+    _this.getAvailableKey = function (preferredKey, formData) {
+      var uiSchema = _this.props.uiSchema;
+      var _getUiOptions = utils.getUiOptions(uiSchema),
+        _getUiOptions$duplica = _getUiOptions.duplicateKeySuffixSeparator,
+        duplicateKeySuffixSeparator = _getUiOptions$duplica === void 0 ? "-" : _getUiOptions$duplica;
+      var index = 0;
+      var newKey = preferredKey;
       while (newKey in formData) {
-        newKey = `${preferredKey}${duplicateKeySuffixSeparator}${++index}`;
+        newKey = "" + preferredKey + duplicateKeySuffixSeparator + ++index;
       }
       return newKey;
     };
-    this.onKeyChange = oldValue => {
-      return (value, newErrorSchema) => {
+    _this.onKeyChange = function (oldValue) {
+      return function (value, newErrorSchema) {
+        var _newKeys, _extends4;
         if (oldValue === value) {
           return;
         }
-        const {
-          formData,
-          onChange,
-          errorSchema
-        } = this.props;
-        value = this.getAvailableKey(value, formData);
-        const newFormData = {
-          ...formData
-        };
-        const newKeys = {
-          [oldValue]: value
-        };
-        const keyValues = Object.keys(newFormData).map(key => {
-          const newKey = newKeys[key] || key;
-          return {
-            [newKey]: newFormData[key]
-          };
+        var _this$props3 = _this.props,
+          formData = _this$props3.formData,
+          onChange = _this$props3.onChange,
+          errorSchema = _this$props3.errorSchema;
+        value = _this.getAvailableKey(value, formData);
+        var newFormData = _extends({}, formData);
+        var newKeys = (_newKeys = {}, _newKeys[oldValue] = value, _newKeys);
+        var keyValues = Object.keys(newFormData).map(function (key) {
+          var _ref;
+          var newKey = newKeys[key] || key;
+          return _ref = {}, _ref[newKey] = newFormData[key], _ref;
         });
-        const renamedObj = Object.assign({}, ...keyValues);
-        this.setState({
+        var renamedObj = Object.assign.apply(Object, [{}].concat(keyValues));
+        _this.setState({
           wasPropertyKeyModified: true
         });
-        onChange(renamedObj, errorSchema && errorSchema && {
-          ...errorSchema,
-          [value]: newErrorSchema
-        });
+        onChange(renamedObj, errorSchema && errorSchema && _extends({}, errorSchema, (_extends4 = {}, _extends4[value] = newErrorSchema, _extends4)));
       };
     };
-    this.handleAddClick = schema => () => {
-      if (!schema.additionalProperties) {
-        return;
-      }
-      const {
-        formData,
-        onChange,
-        registry
-      } = this.props;
-      const newFormData = {
-        ...formData
-      };
-      let type = undefined;
-      if (isObject__default["default"](schema.additionalProperties)) {
-        type = schema.additionalProperties.type;
-        if (utils.REF_KEY in schema.additionalProperties) {
-          const {
-            schemaUtils
-          } = registry;
-          const refSchema = schemaUtils.retrieveSchema({
-            $ref: schema.additionalProperties[utils.REF_KEY]
-          }, formData);
-          type = refSchema.type;
+    _this.handleAddClick = function (schema) {
+      return function () {
+        if (!schema.additionalProperties) {
+          return;
         }
-      }
-      const newKey = this.getAvailableKey("newKey", newFormData);
-      // Cast this to make the `set` work properly
-      set__default["default"](newFormData, newKey, this.getDefaultValue(type));
-      onChange(newFormData);
+        var _this$props4 = _this.props,
+          formData = _this$props4.formData,
+          onChange = _this$props4.onChange,
+          registry = _this$props4.registry;
+        var newFormData = _extends({}, formData);
+        var type = undefined;
+        if (isObject__default["default"](schema.additionalProperties)) {
+          type = schema.additionalProperties.type;
+          if (utils.REF_KEY in schema.additionalProperties) {
+            var schemaUtils = registry.schemaUtils;
+            var refSchema = schemaUtils.retrieveSchema({
+              $ref: schema.additionalProperties[utils.REF_KEY]
+            }, formData);
+            type = refSchema.type;
+          }
+        }
+        var newKey = _this.getAvailableKey("newKey", newFormData);
+        // Cast this to make the `set` work properly
+        set__default["default"](newFormData, newKey, _this.getDefaultValue(type));
+        onChange(newFormData);
+      };
     };
+    return _this;
   }
+  var _proto = ObjectField.prototype;
   /** Returns a flag indicating whether the `name` field is required in the object schema
    *
    * @param name - The name of the field to check for required-ness
    * @returns - True if the field `name` is required, false otherwise
    */
-  isRequired(name) {
-    const {
-      schema
-    } = this.props;
+  _proto.isRequired = function isRequired(name) {
+    var schema = this.props.schema;
     return Array.isArray(schema.required) && schema.required.indexOf(name) !== -1;
   }
   /** Returns the `onPropertyChange` handler for the `name` field. Handles the special case where a user is attempting
@@ -1298,13 +1352,12 @@ class ObjectField extends React.Component {
    * @param name - The name of the property
    * @param addedByAdditionalProperties - Flag indicating whether this property is an additional property
    * @returns - The onPropertyChange callback for the `name` property
-   */
-
+   */;
   /** Returns a default value to be used for a new additional schema property of the given `type`
    *
    * @param type - The type of the new additional schema property
    */
-  getDefaultValue(type) {
+  _proto.getDefaultValue = function getDefaultValue(type) {
     switch (type) {
       case "string":
         return "New Value";
@@ -1327,46 +1380,44 @@ class ObjectField extends React.Component {
    * default data for that field has been added to the formData.
    *
    * @param schema - The schema element to which the new property is being added
-   */
-
+   */;
   /** Renders the `ObjectField` from the given props
    */
-  render() {
-    const {
-      schema: rawSchema,
-      uiSchema = {},
-      formData,
-      errorSchema,
-      idSchema,
-      name,
-      required = false,
-      disabled = false,
-      readonly = false,
-      hideError,
-      idPrefix,
-      idSeparator,
-      onBlur,
-      onFocus,
-      registry
-    } = this.props;
-    const {
-      fields,
-      formContext,
-      schemaUtils
-    } = registry;
-    const {
-      SchemaField
-    } = fields;
-    const schema = schemaUtils.retrieveSchema(rawSchema, formData);
-    const uiOptions = utils.getUiOptions(uiSchema);
-    const {
-      properties: schemaProperties = {}
-    } = schema;
-    const title = schema.title === undefined ? name : schema.title;
-    const description = uiOptions.description || schema.description;
-    let orderedProperties;
+  _proto.render = function render() {
+    var _this2 = this;
+    var _this$props5 = this.props,
+      rawSchema = _this$props5.schema,
+      _this$props5$uiSchema = _this$props5.uiSchema,
+      uiSchema = _this$props5$uiSchema === void 0 ? {} : _this$props5$uiSchema,
+      formData = _this$props5.formData,
+      errorSchema = _this$props5.errorSchema,
+      idSchema = _this$props5.idSchema,
+      name = _this$props5.name,
+      _this$props5$required = _this$props5.required,
+      required = _this$props5$required === void 0 ? false : _this$props5$required,
+      _this$props5$disabled = _this$props5.disabled,
+      disabled = _this$props5$disabled === void 0 ? false : _this$props5$disabled,
+      _this$props5$readonly = _this$props5.readonly,
+      readonly = _this$props5$readonly === void 0 ? false : _this$props5$readonly,
+      hideError = _this$props5.hideError,
+      idPrefix = _this$props5.idPrefix,
+      idSeparator = _this$props5.idSeparator,
+      onBlur = _this$props5.onBlur,
+      onFocus = _this$props5.onFocus,
+      registry = _this$props5.registry;
+    var fields = registry.fields,
+      formContext = registry.formContext,
+      schemaUtils = registry.schemaUtils;
+    var SchemaField = fields.SchemaField;
+    var schema = schemaUtils.retrieveSchema(rawSchema, formData);
+    var uiOptions = utils.getUiOptions(uiSchema);
+    var _schema$properties = schema.properties,
+      schemaProperties = _schema$properties === void 0 ? {} : _schema$properties;
+    var title = schema.title === undefined ? name : schema.title;
+    var description = uiOptions.description || schema.description;
+    var orderedProperties;
     try {
-      const properties = Object.keys(schemaProperties);
+      var properties = Object.keys(schemaProperties);
       orderedProperties = utils.orderProperties(properties, uiOptions.order);
     } catch (err) {
       return /*#__PURE__*/React__default["default"].createElement("div", null, /*#__PURE__*/React__default["default"].createElement("p", {
@@ -1376,20 +1427,20 @@ class ObjectField extends React.Component {
         }
       }, "Invalid ", name || "root", " object field configuration:", /*#__PURE__*/React__default["default"].createElement("em", null, err.message), "."), /*#__PURE__*/React__default["default"].createElement("pre", null, JSON.stringify(schema)));
     }
-    const Template = utils.getTemplate("ObjectFieldTemplate", registry, uiOptions);
-    const templateProps = {
+    var Template = utils.getTemplate("ObjectFieldTemplate", registry, uiOptions);
+    var templateProps = {
       title: uiOptions.title || title,
-      description,
-      properties: orderedProperties.map(name => {
-        const addedByAdditionalProperties = has__default["default"](schema, [utils.PROPERTIES_KEY, name, utils.ADDITIONAL_PROPERTY_FLAG]);
-        const fieldUiSchema = addedByAdditionalProperties ? uiSchema.additionalProperties : uiSchema[name];
-        const hidden = utils.getUiOptions(fieldUiSchema).widget === "hidden";
-        const fieldIdSchema = get__default["default"](idSchema, [name], {});
+      description: description,
+      properties: orderedProperties.map(function (name) {
+        var addedByAdditionalProperties = has__default["default"](schema, [utils.PROPERTIES_KEY, name, utils.ADDITIONAL_PROPERTY_FLAG]);
+        var fieldUiSchema = addedByAdditionalProperties ? uiSchema.additionalProperties : uiSchema[name];
+        var hidden = utils.getUiOptions(fieldUiSchema).widget === "hidden";
+        var fieldIdSchema = get__default["default"](idSchema, [name], {});
         return {
           content: /*#__PURE__*/React__default["default"].createElement(SchemaField, {
             key: name,
             name: name,
-            required: this.isRequired(name),
+            required: _this2.isRequired(name),
             schema: get__default["default"](schema, [utils.PROPERTIES_KEY, name], {}),
             uiSchema: fieldUiSchema,
             errorSchema: get__default["default"](errorSchema, name),
@@ -1398,50 +1449,51 @@ class ObjectField extends React.Component {
             idSeparator: idSeparator,
             formData: get__default["default"](formData, name),
             formContext: formContext,
-            wasPropertyKeyModified: this.state.wasPropertyKeyModified,
-            onKeyChange: this.onKeyChange(name),
-            onChange: this.onPropertyChange(name, addedByAdditionalProperties),
+            wasPropertyKeyModified: _this2.state.wasPropertyKeyModified,
+            onKeyChange: _this2.onKeyChange(name),
+            onChange: _this2.onPropertyChange(name, addedByAdditionalProperties),
             onBlur: onBlur,
             onFocus: onFocus,
             registry: registry,
             disabled: disabled,
             readonly: readonly,
             hideError: hideError,
-            onDropPropertyClick: this.onDropPropertyClick
+            onDropPropertyClick: _this2.onDropPropertyClick
           }),
-          name,
-          readonly,
-          disabled,
-          required,
-          hidden
+          name: name,
+          readonly: readonly,
+          disabled: disabled,
+          required: required,
+          hidden: hidden
         };
       }),
-      readonly,
-      disabled,
-      required,
-      idSchema,
-      uiSchema,
-      schema,
-      formData,
-      formContext,
-      registry
+      readonly: readonly,
+      disabled: disabled,
+      required: required,
+      idSchema: idSchema,
+      uiSchema: uiSchema,
+      schema: schema,
+      formData: formData,
+      formContext: formContext,
+      registry: registry
     };
-    return /*#__PURE__*/React__default["default"].createElement(Template, {
-      ...templateProps,
+    return /*#__PURE__*/React__default["default"].createElement(Template, _extends({}, templateProps, {
       onAddClick: this.handleAddClick
-    });
-  }
-}
+    }));
+  };
+  return ObjectField;
+}(React.Component);
 
+var _excluded$6 = ["__errors"];
 /** The map of component type to FieldName */
-const COMPONENT_TYPES = {
+var COMPONENT_TYPES = {
   array: "ArrayField",
-  boolean: "BooleanField",
+  "boolean": "BooleanField",
   integer: "NumberField",
   number: "NumberField",
   object: "ObjectField",
   string: "StringField",
-  null: "NullField"
+  "null": "NullField"
 };
 /** Computes and returns which `Field` implementation to return in order to render the field represented by the
  * `schema`. The `uiOptions` are used to alter what potential `Field` implementation is actually returned. If no
@@ -1454,30 +1506,30 @@ const COMPONENT_TYPES = {
  * @returns - The `Field` component that is used to render the actual field data
  */
 function getFieldComponent(schema, uiOptions, idSchema, registry) {
-  const field = uiOptions.field;
-  const {
-    fields
-  } = registry;
+  var field = uiOptions.field;
+  var fields = registry.fields;
   if (typeof field === "function") {
     return field;
   }
   if (typeof field === "string" && field in fields) {
     return fields[field];
   }
-  const schemaType = utils.getSchemaType(schema);
-  const type = Array.isArray(schemaType) ? schemaType[0] : schemaType || "";
-  const componentName = COMPONENT_TYPES[type];
+  var schemaType = utils.getSchemaType(schema);
+  var type = Array.isArray(schemaType) ? schemaType[0] : schemaType || "";
+  var componentName = COMPONENT_TYPES[type];
   // If the type is not defined and the schema uses 'anyOf' or 'oneOf', don't
   // render a field and let the MultiSchemaField component handle the form display
   if (!componentName && (schema.anyOf || schema.oneOf)) {
-    return () => null;
+    return function () {
+      return null;
+    };
   }
-  return componentName in fields ? fields[componentName] : () => {
-    const UnsupportedFieldTemplate = utils.getTemplate("UnsupportedFieldTemplate", registry, uiOptions);
+  return componentName in fields ? fields[componentName] : function () {
+    var UnsupportedFieldTemplate = utils.getTemplate("UnsupportedFieldTemplate", registry, uiOptions);
     return /*#__PURE__*/React__default["default"].createElement(UnsupportedFieldTemplate, {
       schema: schema,
       idSchema: idSchema,
-      reason: `Unknown field type ${schema.type}`,
+      reason: "Unknown field type " + schema.type,
       registry: registry
     });
   };
@@ -1489,63 +1541,58 @@ function getFieldComponent(schema, uiOptions, idSchema, registry) {
  * @param props - The `FieldProps` for this component
  */
 function SchemaFieldRender(props) {
-  const {
-    schema: _schema,
-    idSchema: _idSchema,
-    uiSchema,
-    formData,
-    errorSchema,
-    idPrefix,
-    idSeparator,
-    name,
-    onChange,
-    onKeyChange,
-    onDropPropertyClick,
-    required,
-    registry,
-    wasPropertyKeyModified = false
-  } = props;
-  const {
-    formContext,
-    schemaUtils
-  } = registry;
-  const uiOptions = utils.getUiOptions(uiSchema);
-  const FieldTemplate = utils.getTemplate("FieldTemplate", registry, uiOptions);
-  const DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, uiOptions);
-  const FieldHelpTemplate = utils.getTemplate("FieldHelpTemplate", registry, uiOptions);
-  const FieldErrorTemplate = utils.getTemplate("FieldErrorTemplate", registry, uiOptions);
-  const schema = schemaUtils.retrieveSchema(_schema, formData);
-  const fieldId = _idSchema[utils.ID_KEY];
-  const idSchema = utils.mergeObjects(schemaUtils.toIdSchema(schema, fieldId, formData, idPrefix, idSeparator), _idSchema);
+  var _schema = props.schema,
+    _idSchema = props.idSchema,
+    uiSchema = props.uiSchema,
+    formData = props.formData,
+    errorSchema = props.errorSchema,
+    idPrefix = props.idPrefix,
+    idSeparator = props.idSeparator,
+    name = props.name,
+    onChange = props.onChange,
+    onKeyChange = props.onKeyChange,
+    onDropPropertyClick = props.onDropPropertyClick,
+    required = props.required,
+    registry = props.registry,
+    _props$wasPropertyKey = props.wasPropertyKeyModified,
+    wasPropertyKeyModified = _props$wasPropertyKey === void 0 ? false : _props$wasPropertyKey;
+  var formContext = registry.formContext,
+    schemaUtils = registry.schemaUtils;
+  var uiOptions = utils.getUiOptions(uiSchema);
+  var FieldTemplate = utils.getTemplate("FieldTemplate", registry, uiOptions);
+  var DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, uiOptions);
+  var FieldHelpTemplate = utils.getTemplate("FieldHelpTemplate", registry, uiOptions);
+  var FieldErrorTemplate = utils.getTemplate("FieldErrorTemplate", registry, uiOptions);
+  var schema = schemaUtils.retrieveSchema(_schema, formData);
+  var fieldId = _idSchema[utils.ID_KEY];
+  var idSchema = utils.mergeObjects(schemaUtils.toIdSchema(schema, fieldId, formData, idPrefix, idSeparator), _idSchema);
   /** Intermediary `onChange` handler for field components that will inject the `id` of the current field into the
    * `onChange` chain if it is not already being provided from a deeper level in the hierarchy
    */
-  const handleFieldComponentChange = React__default["default"].useCallback((formData, newErrorSchema, id) => {
-    const theId = id || fieldId;
+  var handleFieldComponentChange = React__default["default"].useCallback(function (formData, newErrorSchema, id) {
+    var theId = id || fieldId;
     return onChange(formData, newErrorSchema, theId);
   }, [fieldId, onChange]);
-  const FieldComponent = getFieldComponent(schema, uiOptions, idSchema, registry);
-  const disabled = Boolean(props.disabled || uiOptions.disabled);
-  const readonly = Boolean(props.readonly || uiOptions.readonly || props.schema.readOnly || schema.readOnly);
-  const uiSchemaHideError = uiOptions.hideError;
+  var FieldComponent = getFieldComponent(schema, uiOptions, idSchema, registry);
+  var disabled = Boolean(props.disabled || uiOptions.disabled);
+  var readonly = Boolean(props.readonly || uiOptions.readonly || props.schema.readOnly || schema.readOnly);
+  var uiSchemaHideError = uiOptions.hideError;
   // Set hideError to the value provided in the uiSchema, otherwise stick with the prop to propagate to children
-  const hideError = uiSchemaHideError === undefined ? props.hideError : Boolean(uiSchemaHideError);
-  const autofocus = Boolean(props.autofocus || uiOptions.autofocus);
+  var hideError = uiSchemaHideError === undefined ? props.hideError : Boolean(uiSchemaHideError);
+  var autofocus = Boolean(props.autofocus || uiOptions.autofocus);
   if (Object.keys(schema).length === 0) {
     return null;
   }
-  const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema);
-  const {
-    __errors,
-    ...fieldErrorSchema
-  } = errorSchema || {};
+  var displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema);
+  var _ref = errorSchema || {},
+    __errors = _ref.__errors,
+    fieldErrorSchema = _objectWithoutPropertiesLoose(_ref, _excluded$6);
   // See #439: uiSchema: Don't pass consumed class names to child components
-  const fieldUiSchema = omit__default["default"](uiSchema, ["ui:classNames", "classNames"]);
+  var fieldUiSchema = omit__default["default"](uiSchema, ["ui:classNames", "classNames"]);
   if ("ui:options" in fieldUiSchema) {
     fieldUiSchema["ui:options"] = omit__default["default"](fieldUiSchema["ui:options"], ["classNames"]);
   }
-  const field = /*#__PURE__*/React__default["default"].createElement(FieldComponent, {
-    ...props,
+  var field = /*#__PURE__*/React__default["default"].createElement(FieldComponent, _extends({}, props, {
     onChange: handleFieldComponentChange,
     idSchema: idSchema,
     schema: schema,
@@ -1557,19 +1604,19 @@ function SchemaFieldRender(props) {
     errorSchema: fieldErrorSchema,
     formContext: formContext,
     rawErrors: __errors
-  });
-  const id = idSchema[utils.ID_KEY];
+  }));
+  var id = idSchema[utils.ID_KEY];
   // If this schema has a title defined, but the user has set a new key/label, retain their input.
-  let label;
+  var label;
   if (wasPropertyKeyModified) {
     label = name;
   } else {
     label = utils.ADDITIONAL_PROPERTY_FLAG in schema ? name : uiOptions.title || props.schema.title || schema.title || name;
   }
-  const description = uiOptions.description || props.schema.description || schema.description || "";
-  const help = uiOptions.help;
-  const hidden = uiOptions.widget === "hidden";
-  const classNames = ["form-group", "field", `field-${schema.type}`];
+  var description = uiOptions.description || props.schema.description || schema.description || "";
+  var help = uiOptions.help;
+  var hidden = uiOptions.widget === "hidden";
+  var classNames = ["form-group", "field", "field-" + schema.type];
   if (!hideError && __errors && __errors.length > 0) {
     classNames.push("field-error has-error has-danger");
   }
@@ -1582,7 +1629,7 @@ function SchemaFieldRender(props) {
   if (uiOptions.classNames) {
     classNames.push(uiOptions.classNames);
   }
-  const helpComponent = /*#__PURE__*/React__default["default"].createElement(FieldHelpTemplate, {
+  var helpComponent = /*#__PURE__*/React__default["default"].createElement(FieldHelpTemplate, {
     help: help,
     idSchema: idSchema,
     schema: schema,
@@ -1590,7 +1637,7 @@ function SchemaFieldRender(props) {
     hasErrors: !hideError && __errors && __errors.length > 0,
     registry: registry
   });
-  const errorsComponent = hideError ? undefined : /*#__PURE__*/React__default["default"].createElement(FieldErrorTemplate, {
+  var errorsComponent = hideError ? undefined : /*#__PURE__*/React__default["default"].createElement(FieldErrorTemplate, {
     errors: __errors,
     errorSchema: errorSchema,
     idSchema: idSchema,
@@ -1598,9 +1645,9 @@ function SchemaFieldRender(props) {
     uiSchema: uiSchema,
     registry: registry
   });
-  const fieldProps = {
+  var fieldProps = {
     description: /*#__PURE__*/React__default["default"].createElement(DescriptionFieldTemplate, {
-      id: `${id}__description`,
+      id: id + "__description",
       description: description,
       schema: schema,
       uiSchema: uiSchema,
@@ -1611,29 +1658,27 @@ function SchemaFieldRender(props) {
     rawHelp: typeof help === "string" ? help : undefined,
     errors: errorsComponent,
     rawErrors: hideError ? undefined : __errors,
-    id,
-    label,
-    hidden,
-    onChange,
-    onKeyChange,
-    onDropPropertyClick,
-    required,
-    disabled,
-    readonly,
-    hideError,
-    displayLabel,
+    id: id,
+    label: label,
+    hidden: hidden,
+    onChange: onChange,
+    onKeyChange: onKeyChange,
+    onDropPropertyClick: onDropPropertyClick,
+    required: required,
+    disabled: disabled,
+    readonly: readonly,
+    hideError: hideError,
+    displayLabel: displayLabel,
     classNames: classNames.join(" ").trim(),
-    formContext,
-    formData,
-    schema,
-    uiSchema,
-    registry
+    formContext: formContext,
+    formData: formData,
+    schema: schema,
+    uiSchema: uiSchema,
+    registry: registry
   };
-  const _AnyOfField = registry.fields.AnyOfField;
-  const _OneOfField = registry.fields.OneOfField;
-  return /*#__PURE__*/React__default["default"].createElement(FieldTemplate, {
-    ...fieldProps
-  }, /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, field, schema.anyOf && !(uiSchema !== null && uiSchema !== void 0 && uiSchema["ui:field"]) && !schemaUtils.isSelect(schema) && /*#__PURE__*/React__default["default"].createElement(_AnyOfField, {
+  var _AnyOfField = registry.fields.AnyOfField;
+  var _OneOfField = registry.fields.OneOfField;
+  return /*#__PURE__*/React__default["default"].createElement(FieldTemplate, _extends({}, fieldProps), /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, field, schema.anyOf && !(uiSchema !== null && uiSchema !== void 0 && uiSchema["ui:field"]) && !schemaUtils.isSelect(schema) && /*#__PURE__*/React__default["default"].createElement(_AnyOfField, {
     name: name,
     disabled: disabled,
     readonly: readonly,
@@ -1647,7 +1692,9 @@ function SchemaFieldRender(props) {
     onBlur: props.onBlur,
     onChange: props.onChange,
     onFocus: props.onFocus,
-    options: schema.anyOf.map(_schema => schemaUtils.retrieveSchema(isObject__default["default"](_schema) ? _schema : {}, formData)),
+    options: schema.anyOf.map(function (_schema) {
+      return schemaUtils.retrieveSchema(isObject__default["default"](_schema) ? _schema : {}, formData);
+    }),
     baseType: schema.type,
     registry: registry,
     schema: schema,
@@ -1666,7 +1713,9 @@ function SchemaFieldRender(props) {
     onBlur: props.onBlur,
     onChange: props.onChange,
     onFocus: props.onFocus,
-    options: schema.oneOf.map(_schema => schemaUtils.retrieveSchema(isObject__default["default"](_schema) ? _schema : {}, formData)),
+    options: schema.oneOf.map(function (_schema) {
+      return schemaUtils.retrieveSchema(isObject__default["default"](_schema) ? _schema : {}, formData);
+    }),
     baseType: schema.type,
     registry: registry,
     schema: schema,
@@ -1676,63 +1725,65 @@ function SchemaFieldRender(props) {
 /** The `SchemaField` component determines whether it is necessary to rerender the component based on any props changes
  * and if so, calls the `SchemaFieldRender` component with the props.
  */
-class SchemaField extends React__default["default"].Component {
-  shouldComponentUpdate(nextProps) {
-    return !utils.deepEquals(this.props, nextProps);
-  }
-  render() {
-    return /*#__PURE__*/React__default["default"].createElement(SchemaFieldRender, {
-      ...this.props
-    });
+var SchemaField = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(SchemaField, _React$Component);
+  function SchemaField() {
+    return _React$Component.apply(this, arguments) || this;
   }
-}
+  var _proto = SchemaField.prototype;
+  _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
+    return !utils.deepEquals(this.props, nextProps);
+  };
+  _proto.render = function render() {
+    return /*#__PURE__*/React__default["default"].createElement(SchemaFieldRender, _extends({}, this.props));
+  };
+  return SchemaField;
+}(React__default["default"].Component);
 
+var _excluded$5 = ["widget", "placeholder"];
 /** The `StringField` component is used to render a schema field that represents a string type
  *
  * @param props - The `FieldProps` for this template
  */
 function StringField(props) {
-  const {
-    schema,
-    name,
-    uiSchema,
-    idSchema,
-    formData,
-    required,
-    disabled = false,
-    readonly = false,
-    autofocus = false,
-    onChange,
-    onBlur,
-    onFocus,
-    registry,
-    rawErrors
-  } = props;
-  const {
-    title,
-    format
-  } = schema;
-  const {
-    widgets,
-    formContext,
-    schemaUtils
-  } = registry;
-  const enumOptions = schemaUtils.isSelect(schema) ? utils.optionsList(schema) : undefined;
-  let defaultWidget = enumOptions ? "select" : "text";
+  var schema = props.schema,
+    name = props.name,
+    uiSchema = props.uiSchema,
+    idSchema = props.idSchema,
+    formData = props.formData,
+    required = props.required,
+    _props$disabled = props.disabled,
+    disabled = _props$disabled === void 0 ? false : _props$disabled,
+    _props$readonly = props.readonly,
+    readonly = _props$readonly === void 0 ? false : _props$readonly,
+    _props$autofocus = props.autofocus,
+    autofocus = _props$autofocus === void 0 ? false : _props$autofocus,
+    onChange = props.onChange,
+    onBlur = props.onBlur,
+    onFocus = props.onFocus,
+    registry = props.registry,
+    rawErrors = props.rawErrors;
+  var title = schema.title,
+    format = schema.format;
+  var widgets = registry.widgets,
+    formContext = registry.formContext,
+    schemaUtils = registry.schemaUtils;
+  var enumOptions = schemaUtils.isSelect(schema) ? utils.optionsList(schema) : undefined;
+  var defaultWidget = enumOptions ? "select" : "text";
   if (format && utils.hasWidget(schema, format, widgets)) {
     defaultWidget = format;
   }
-  const {
-    widget = defaultWidget,
-    placeholder = "",
-    ...options
-  } = utils.getUiOptions(uiSchema);
-  const Widget = utils.getWidget(schema, widget, widgets);
+  var _getUiOptions = utils.getUiOptions(uiSchema),
+    _getUiOptions$widget = _getUiOptions.widget,
+    widget = _getUiOptions$widget === void 0 ? defaultWidget : _getUiOptions$widget,
+    _getUiOptions$placeho = _getUiOptions.placeholder,
+    placeholder = _getUiOptions$placeho === void 0 ? "" : _getUiOptions$placeho,
+    options = _objectWithoutPropertiesLoose(_getUiOptions, _excluded$5);
+  var Widget = utils.getWidget(schema, widget, widgets);
   return /*#__PURE__*/React__default["default"].createElement(Widget, {
-    options: {
-      ...options,
-      enumOptions
-    },
+    options: _extends({}, options, {
+      enumOptions: enumOptions
+    }),
     schema: schema,
     uiSchema: uiSchema,
     id: idSchema && idSchema.$id,
@@ -1758,11 +1809,9 @@ function StringField(props) {
  * @param props - The `FieldProps` for this template
  */
 function NullField(props) {
-  const {
-    formData,
-    onChange
-  } = props;
-  React.useEffect(() => {
+  var formData = props.formData,
+    onChange = props.onChange;
+  React.useEffect(function () {
     if (formData === undefined) {
       onChange(null);
     }
@@ -1775,13 +1824,13 @@ function fields() {
     AnyOfField: AnyOfField,
     ArrayField: ArrayField,
     // ArrayField falls back to SchemaField if ArraySchemaField is not defined, which it isn't by default
-    BooleanField,
-    NumberField,
-    ObjectField,
+    BooleanField: BooleanField,
+    NumberField: NumberField,
+    ObjectField: ObjectField,
     OneOfField: AnyOfField,
-    SchemaField,
-    StringField,
-    NullField
+    SchemaField: SchemaField,
+    StringField: StringField,
+    NullField: NullField
   };
 }
 
@@ -1791,22 +1840,19 @@ function fields() {
  * @param props - The `ArrayFieldDescriptionProps` for the component
  */
 function ArrayFieldDescriptionTemplate(props) {
-  const {
-    idSchema,
-    description,
-    registry,
-    schema,
-    uiSchema
-  } = props;
-  const options = utils.getUiOptions(uiSchema);
-  const {
-    label: displayLabel = true
-  } = options;
+  var idSchema = props.idSchema,
+    description = props.description,
+    registry = props.registry,
+    schema = props.schema,
+    uiSchema = props.uiSchema;
+  var options = utils.getUiOptions(uiSchema);
+  var _options$label = options.label,
+    displayLabel = _options$label === void 0 ? true : _options$label;
   if (!description || !displayLabel) {
     return null;
   }
-  const DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, options);
-  const id = `${idSchema.$id}__description`;
+  var DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, options);
+  var id = idSchema.$id + "__description";
   return /*#__PURE__*/React__default["default"].createElement(DescriptionFieldTemplate, {
     id: id,
     description: description,
@@ -1821,27 +1867,24 @@ function ArrayFieldDescriptionTemplate(props) {
  * @param props - The `ArrayFieldTemplateItemType` props for the component
  */
 function ArrayFieldItemTemplate(props) {
-  const {
-    children,
-    className,
-    disabled,
-    hasToolbar,
-    hasMoveDown,
-    hasMoveUp,
-    hasRemove,
-    index,
-    onDropIndexClick,
-    onReorderClick,
-    readonly,
-    registry,
-    uiSchema
-  } = props;
-  const {
-    MoveDownButton,
-    MoveUpButton,
-    RemoveButton
-  } = registry.templates.ButtonTemplates;
-  const btnStyle = {
+  var children = props.children,
+    className = props.className,
+    disabled = props.disabled,
+    hasToolbar = props.hasToolbar,
+    hasMoveDown = props.hasMoveDown,
+    hasMoveUp = props.hasMoveUp,
+    hasRemove = props.hasRemove,
+    index = props.index,
+    onDropIndexClick = props.onDropIndexClick,
+    onReorderClick = props.onReorderClick,
+    readonly = props.readonly,
+    registry = props.registry,
+    uiSchema = props.uiSchema;
+  var _registry$templates$B = registry.templates.ButtonTemplates,
+    MoveDownButton = _registry$templates$B.MoveDownButton,
+    MoveUpButton = _registry$templates$B.MoveUpButton,
+    RemoveButton = _registry$templates$B.RemoveButton;
+  var btnStyle = {
     flex: 1,
     paddingLeft: 6,
     paddingRight: 6,
@@ -1877,35 +1920,30 @@ function ArrayFieldItemTemplate(props) {
   }))));
 }
 
+var _excluded$4 = ["key"];
 /** The `ArrayFieldTemplate` component is the template used to render all items in an array.
  *
  * @param props - The `ArrayFieldTemplateItemType` props for the component
  */
 function ArrayFieldTemplate(props) {
-  const {
-    canAdd,
-    className,
-    disabled,
-    idSchema,
-    uiSchema,
-    items,
-    onAddClick,
-    readonly,
-    registry,
-    required,
-    schema,
-    title
-  } = props;
-  const uiOptions = utils.getUiOptions(uiSchema);
-  const ArrayFieldDescriptionTemplate = utils.getTemplate("ArrayFieldDescriptionTemplate", registry, uiOptions);
-  const ArrayFieldItemTemplate = utils.getTemplate("ArrayFieldItemTemplate", registry, uiOptions);
-  const ArrayFieldTitleTemplate = utils.getTemplate("ArrayFieldTitleTemplate", registry, uiOptions);
+  var canAdd = props.canAdd,
+    className = props.className,
+    disabled = props.disabled,
+    idSchema = props.idSchema,
+    uiSchema = props.uiSchema,
+    items = props.items,
+    onAddClick = props.onAddClick,
+    readonly = props.readonly,
+    registry = props.registry,
+    required = props.required,
+    schema = props.schema,
+    title = props.title;
+  var uiOptions = utils.getUiOptions(uiSchema);
+  var ArrayFieldDescriptionTemplate = utils.getTemplate("ArrayFieldDescriptionTemplate", registry, uiOptions);
+  var ArrayFieldItemTemplate = utils.getTemplate("ArrayFieldItemTemplate", registry, uiOptions);
+  var ArrayFieldTitleTemplate = utils.getTemplate("ArrayFieldTitleTemplate", registry, uiOptions);
   // Button templates are not overridden in the uiSchema
-  const {
-    ButtonTemplates: {
-      AddButton
-    }
-  } = registry.templates;
+  var AddButton = registry.templates.ButtonTemplates.AddButton;
   return /*#__PURE__*/React__default["default"].createElement("fieldset", {
     className: className,
     id: idSchema.$id
@@ -1924,15 +1962,12 @@ function ArrayFieldTemplate(props) {
     registry: registry
   }), /*#__PURE__*/React__default["default"].createElement("div", {
     className: "row array-item-list"
-  }, items && items.map(_ref => {
-    let {
-      key,
-      ...itemProps
-    } = _ref;
-    return /*#__PURE__*/React__default["default"].createElement(ArrayFieldItemTemplate, {
-      key: key,
-      ...itemProps
-    });
+  }, items && items.map(function (_ref) {
+    var key = _ref.key,
+      itemProps = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+    return /*#__PURE__*/React__default["default"].createElement(ArrayFieldItemTemplate, _extends({
+      key: key
+    }, itemProps));
   })), canAdd && /*#__PURE__*/React__default["default"].createElement(AddButton, {
     className: "array-item-add",
     onClick: onAddClick,
@@ -1947,23 +1982,20 @@ function ArrayFieldTemplate(props) {
  * @param props - The `ArrayFieldTitleProps` for the component
  */
 function ArrayFieldTitleTemplate(props) {
-  const {
-    idSchema,
-    title,
-    schema,
-    uiSchema,
-    required,
-    registry
-  } = props;
-  const options = utils.getUiOptions(uiSchema);
-  const {
-    label: displayLabel = true
-  } = options;
+  var idSchema = props.idSchema,
+    title = props.title,
+    schema = props.schema,
+    uiSchema = props.uiSchema,
+    required = props.required,
+    registry = props.registry;
+  var options = utils.getUiOptions(uiSchema);
+  var _options$label = options.label,
+    displayLabel = _options$label === void 0 ? true : _options$label;
   if (!title || !displayLabel) {
     return null;
   }
-  const TitleFieldTemplate = utils.getTemplate("TitleFieldTemplate", registry, options);
-  const id = `${idSchema.$id}__title`;
+  var TitleFieldTemplate = utils.getTemplate("TitleFieldTemplate", registry, options);
+  var id = idSchema.$id + "__title";
   return /*#__PURE__*/React__default["default"].createElement(TitleFieldTemplate, {
     id: id,
     title: title,
@@ -1974,6 +2006,7 @@ function ArrayFieldTitleTemplate(props) {
   });
 }
 
+var _excluded$3 = ["id", "value", "readonly", "disabled", "autofocus", "onBlur", "onFocus", "onChange", "options", "schema", "uiSchema", "formContext", "registry", "rawErrors", "type"];
 /** The `BaseInputTemplate` is the template to use to render the basic `<input>` component for the `core` theme.
  * It is used as the template for rendering many of the <input> based widgets that differ by `type` and callbacks only.
  * It can be customized/overridden for other themes or individual implementations as needed.
@@ -1981,161 +2014,136 @@ function ArrayFieldTitleTemplate(props) {
  * @param props - The `WidgetProps` for this template
  */
 function BaseInputTemplate(props) {
-  const {
-    id,
-    value,
-    readonly,
-    disabled,
-    autofocus,
-    onBlur,
-    onFocus,
-    onChange,
-    options,
-    schema,
-    uiSchema,
-    formContext,
-    registry,
-    rawErrors,
-    type,
-    ...rest
-  } = props;
+  var id = props.id,
+    value = props.value,
+    readonly = props.readonly,
+    disabled = props.disabled,
+    autofocus = props.autofocus,
+    onBlur = props.onBlur,
+    onFocus = props.onFocus,
+    onChange = props.onChange,
+    options = props.options,
+    schema = props.schema,
+    type = props.type,
+    rest = _objectWithoutPropertiesLoose(props, _excluded$3);
   // Note: since React 15.2.0 we can't forward unknown element attributes, so we
   // exclude the "options" and "schema" ones here.
   if (!id) {
     console.log("No id for", props);
-    throw new Error(`no id for props ${JSON.stringify(props)}`);
+    throw new Error("no id for props " + JSON.stringify(props));
   }
-  const inputProps = {
-    ...rest,
-    ...utils.getInputProps(schema, type, options)
-  };
-  let inputValue;
+  var inputProps = _extends({}, rest, utils.getInputProps(schema, type, options));
+  var inputValue;
   if (inputProps.type === "number" || inputProps.type === "integer") {
     inputValue = value || value === 0 ? value : "";
   } else {
     inputValue = value == null ? "" : value;
   }
-  const _onChange = React.useCallback(_ref => {
-    let {
-      target: {
-        value
-      }
-    } = _ref;
+  var _onChange = React.useCallback(function (_ref) {
+    var value = _ref.target.value;
     return onChange(value === "" ? options.emptyValue : value);
   }, [onChange, options]);
-  const _onBlur = React.useCallback(_ref2 => {
-    let {
-      target: {
-        value
-      }
-    } = _ref2;
+  var _onBlur = React.useCallback(function (_ref2) {
+    var value = _ref2.target.value;
     return onBlur(id, value);
   }, [onBlur, id]);
-  const _onFocus = React.useCallback(_ref3 => {
-    let {
-      target: {
-        value
-      }
-    } = _ref3;
+  var _onFocus = React.useCallback(function (_ref3) {
+    var value = _ref3.target.value;
     return onFocus(id, value);
   }, [onFocus, id]);
-  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement("input", {
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement("input", _extends({
     id: id,
     name: id,
     className: "form-control",
     readOnly: readonly,
     disabled: disabled,
     autoFocus: autofocus,
-    value: inputValue,
-    ...inputProps,
-    list: schema.examples ? `examples_${id}` : undefined,
+    value: inputValue
+  }, inputProps, {
+    list: schema.examples ? "examples_" + id : undefined,
     onChange: _onChange,
     onBlur: _onBlur,
     onFocus: _onFocus
-  }), Array.isArray(schema.examples) && /*#__PURE__*/React__default["default"].createElement("datalist", {
-    key: `datalist_${id}`,
-    id: `examples_${id}`
-  }, [...new Set(schema.examples.concat(schema.default ? [schema.default] : []))].map(example => /*#__PURE__*/React__default["default"].createElement("option", {
-    key: example,
-    value: example
-  }))));
+  })), Array.isArray(schema.examples) && /*#__PURE__*/React__default["default"].createElement("datalist", {
+    key: "datalist_" + id,
+    id: "examples_" + id
+  }, [].concat(new Set(schema.examples.concat(schema["default"] ? [schema["default"]] : []))).map(function (example) {
+    return /*#__PURE__*/React__default["default"].createElement("option", {
+      key: example,
+      value: example
+    });
+  })));
 }
 
 /** The `SubmitButton` renders a button that represent the `Submit` action on a form
  */
 function SubmitButton(_ref) {
-  let {
-    uiSchema
-  } = _ref;
-  const {
-    submitText,
-    norender,
-    props: submitButtonProps = {}
-  } = utils.getSubmitButtonOptions(uiSchema);
+  var uiSchema = _ref.uiSchema;
+  var _getSubmitButtonOptio = utils.getSubmitButtonOptions(uiSchema),
+    submitText = _getSubmitButtonOptio.submitText,
+    norender = _getSubmitButtonOptio.norender,
+    _getSubmitButtonOptio2 = _getSubmitButtonOptio.props,
+    submitButtonProps = _getSubmitButtonOptio2 === void 0 ? {} : _getSubmitButtonOptio2;
   if (norender) {
     return null;
   }
-  return /*#__PURE__*/React__default["default"].createElement("div", null, /*#__PURE__*/React__default["default"].createElement("button", {
-    type: "submit",
-    ...submitButtonProps,
-    className: `btn btn-info ${submitButtonProps.className}`
-  }, submitText));
+  return /*#__PURE__*/React__default["default"].createElement("div", null, /*#__PURE__*/React__default["default"].createElement("button", _extends({
+    type: "submit"
+  }, submitButtonProps, {
+    className: "btn btn-info " + submitButtonProps.className
+  }), submitText));
 }
 
+var _excluded$2 = ["iconType", "icon", "className", "uiSchema"];
 function IconButton(props) {
-  const {
-    iconType = "default",
-    icon,
-    className,
-    uiSchema,
-    ...otherProps
-  } = props;
-  return /*#__PURE__*/React__default["default"].createElement("button", {
+  var _props$iconType = props.iconType,
+    iconType = _props$iconType === void 0 ? "default" : _props$iconType,
+    icon = props.icon,
+    className = props.className,
+    otherProps = _objectWithoutPropertiesLoose(props, _excluded$2);
+  return /*#__PURE__*/React__default["default"].createElement("button", _extends({
     type: "button",
-    className: `btn btn-${iconType} ${className}`,
-    ...otherProps
-  }, /*#__PURE__*/React__default["default"].createElement("i", {
-    className: `glyphicon glyphicon-${icon}`
+    className: "btn btn-" + iconType + " " + className
+  }, otherProps), /*#__PURE__*/React__default["default"].createElement("i", {
+    className: "glyphicon glyphicon-" + icon
   }));
 }
 function MoveDownButton(props) {
-  return /*#__PURE__*/React__default["default"].createElement(IconButton, {
+  return /*#__PURE__*/React__default["default"].createElement(IconButton, _extends({
     title: "Move down",
-    className: "array-item-move-down",
-    ...props,
+    className: "array-item-move-down"
+  }, props, {
     icon: "arrow-down"
-  });
+  }));
 }
 function MoveUpButton(props) {
-  return /*#__PURE__*/React__default["default"].createElement(IconButton, {
+  return /*#__PURE__*/React__default["default"].createElement(IconButton, _extends({
     title: "Move up",
-    className: "array-item-move-up",
-    ...props,
+    className: "array-item-move-up"
+  }, props, {
     icon: "arrow-up"
-  });
+  }));
 }
 function RemoveButton(props) {
-  return /*#__PURE__*/React__default["default"].createElement(IconButton, {
+  return /*#__PURE__*/React__default["default"].createElement(IconButton, _extends({
     title: "Remove",
-    className: "array-item-remove",
-    ...props,
+    className: "array-item-remove"
+  }, props, {
     iconType: "danger",
     icon: "remove"
-  });
+  }));
 }
 
 /** The `AddButton` renders a button that represent the `Add` action on a form
  */
 function AddButton(_ref) {
-  let {
-    className,
-    onClick,
-    disabled
-  } = _ref;
+  var className = _ref.className,
+    onClick = _ref.onClick,
+    disabled = _ref.disabled;
   return /*#__PURE__*/React__default["default"].createElement("div", {
     className: "row"
   }, /*#__PURE__*/React__default["default"].createElement("p", {
-    className: `col-xs-3 col-xs-offset-9 text-right ${className}`
+    className: "col-xs-3 col-xs-offset-9 text-right " + className
   }, /*#__PURE__*/React__default["default"].createElement(IconButton, {
     iconType: "info",
     icon: "plus",
@@ -2148,11 +2156,11 @@ function AddButton(_ref) {
 
 function buttonTemplates() {
   return {
-    SubmitButton,
-    AddButton,
-    MoveDownButton,
-    MoveUpButton,
-    RemoveButton
+    SubmitButton: SubmitButton,
+    AddButton: AddButton,
+    MoveDownButton: MoveDownButton,
+    MoveUpButton: MoveUpButton,
+    RemoveButton: RemoveButton
   };
 }
 
@@ -2161,10 +2169,8 @@ function buttonTemplates() {
  * @param props - The `DescriptionFieldProps` for this component
  */
 function DescriptionField(props) {
-  const {
-    id,
-    description
-  } = props;
+  var id = props.id,
+    description = props.description;
   if (!description) {
     return null;
   }
@@ -2186,9 +2192,7 @@ function DescriptionField(props) {
  * @param props - The `ErrorListProps` for this component
  */
 function ErrorList(_ref) {
-  let {
-    errors
-  } = _ref;
+  var errors = _ref.errors;
   return /*#__PURE__*/React__default["default"].createElement("div", {
     className: "panel panel-danger errors"
   }, /*#__PURE__*/React__default["default"].createElement("div", {
@@ -2197,7 +2201,7 @@ function ErrorList(_ref) {
     className: "panel-title"
   }, "Errors")), /*#__PURE__*/React__default["default"].createElement("ul", {
     className: "list-group"
-  }, errors.map((error, i) => {
+  }, errors.map(function (error, i) {
     return /*#__PURE__*/React__default["default"].createElement("li", {
       key: i,
       className: "list-group-item text-danger"
@@ -2205,17 +2209,15 @@ function ErrorList(_ref) {
   })));
 }
 
-const REQUIRED_FIELD_SYMBOL$1 = "*";
+var REQUIRED_FIELD_SYMBOL$1 = "*";
 /** Renders a label for a field
  *
  * @param props - The `LabelProps` for this component
  */
 function Label(props) {
-  const {
-    label,
-    required,
-    id
-  } = props;
+  var label = props.label,
+    required = props.required,
+    id = props.id;
   if (!label) {
     return null;
   }
@@ -2233,29 +2235,25 @@ function Label(props) {
  * @param props - The `FieldTemplateProps` for this component
  */
 function FieldTemplate(props) {
-  const {
-    id,
-    label,
-    children,
-    errors,
-    help,
-    description,
-    hidden,
-    required,
-    displayLabel,
-    registry,
-    uiSchema
-  } = props;
-  const uiOptions = utils.getUiOptions(uiSchema);
-  const WrapIfAdditionalTemplate = utils.getTemplate("WrapIfAdditionalTemplate", registry, uiOptions);
+  var id = props.id,
+    label = props.label,
+    children = props.children,
+    errors = props.errors,
+    help = props.help,
+    description = props.description,
+    hidden = props.hidden,
+    required = props.required,
+    displayLabel = props.displayLabel,
+    registry = props.registry,
+    uiSchema = props.uiSchema;
+  var uiOptions = utils.getUiOptions(uiSchema);
+  var WrapIfAdditionalTemplate = utils.getTemplate("WrapIfAdditionalTemplate", registry, uiOptions);
   if (hidden) {
     return /*#__PURE__*/React__default["default"].createElement("div", {
       className: "hidden"
     }, children);
   }
-  return /*#__PURE__*/React__default["default"].createElement(WrapIfAdditionalTemplate, {
-    ...props
-  }, displayLabel && /*#__PURE__*/React__default["default"].createElement(Label, {
+  return /*#__PURE__*/React__default["default"].createElement(WrapIfAdditionalTemplate, _extends({}, props), displayLabel && /*#__PURE__*/React__default["default"].createElement(Label, {
     label: label,
     required: required,
     id: id
@@ -2267,18 +2265,19 @@ function FieldTemplate(props) {
  * @param props - The `FieldErrorProps` for the errors being rendered
  */
 function FieldErrorTemplate(props) {
-  const {
-    errors = [],
-    idSchema
-  } = props;
+  var _props$errors = props.errors,
+    errors = _props$errors === void 0 ? [] : _props$errors,
+    idSchema = props.idSchema;
   if (errors.length === 0) {
     return null;
   }
-  const id = `${idSchema.$id}__error`;
+  var id = idSchema.$id + "__error";
   return /*#__PURE__*/React__default["default"].createElement("div", null, /*#__PURE__*/React__default["default"].createElement("ul", {
     id: id,
     className: "error-detail bs-callout bs-callout-info"
-  }, errors.filter(elem => !!elem).map((error, index) => {
+  }, errors.filter(function (elem) {
+    return !!elem;
+  }).map(function (error, index) {
     return /*#__PURE__*/React__default["default"].createElement("li", {
       className: "text-danger",
       key: index
@@ -2291,14 +2290,12 @@ function FieldErrorTemplate(props) {
  * @param props - The `FieldHelpProps` to be rendered
  */
 function FieldHelpTemplate(props) {
-  const {
-    idSchema,
-    help
-  } = props;
+  var idSchema = props.idSchema,
+    help = props.help;
   if (!help) {
     return null;
   }
-  const id = `${idSchema.$id}__help`;
+  var id = idSchema.$id + "__help";
   if (typeof help === "string") {
     return /*#__PURE__*/React__default["default"].createElement("p", {
       id: id,
@@ -2318,45 +2315,41 @@ function FieldHelpTemplate(props) {
  * @param props - The `ObjectFieldTemplateProps` for this component
  */
 function ObjectFieldTemplate(props) {
-  const {
-    description,
-    disabled,
-    formData,
-    idSchema,
-    onAddClick,
-    properties,
-    readonly,
-    registry,
-    required,
-    schema,
-    title,
-    uiSchema
-  } = props;
-  const options = utils.getUiOptions(uiSchema);
-  const TitleFieldTemplate = utils.getTemplate("TitleFieldTemplate", registry, options);
-  const DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, options);
+  var description = props.description,
+    disabled = props.disabled,
+    formData = props.formData,
+    idSchema = props.idSchema,
+    onAddClick = props.onAddClick,
+    properties = props.properties,
+    readonly = props.readonly,
+    registry = props.registry,
+    required = props.required,
+    schema = props.schema,
+    title = props.title,
+    uiSchema = props.uiSchema;
+  var options = utils.getUiOptions(uiSchema);
+  var TitleFieldTemplate = utils.getTemplate("TitleFieldTemplate", registry, options);
+  var DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, options);
   // Button templates are not overridden in the uiSchema
-  const {
-    ButtonTemplates: {
-      AddButton
-    }
-  } = registry.templates;
+  var AddButton = registry.templates.ButtonTemplates.AddButton;
   return /*#__PURE__*/React__default["default"].createElement("fieldset", {
     id: idSchema.$id
   }, (options.title || title) && /*#__PURE__*/React__default["default"].createElement(TitleFieldTemplate, {
-    id: `${idSchema.$id}__title`,
+    id: idSchema.$id + "__title",
     title: options.title || title,
     required: required,
     schema: schema,
     uiSchema: uiSchema,
     registry: registry
   }), (options.description || description) && /*#__PURE__*/React__default["default"].createElement(DescriptionFieldTemplate, {
-    id: `${idSchema.$id}__description`,
+    id: idSchema.$id + "__description",
     description: options.description || description,
     schema: schema,
     uiSchema: uiSchema,
     registry: registry
-  }), properties.map(prop => prop.content), utils.canExpand(schema, uiSchema, formData) && /*#__PURE__*/React__default["default"].createElement(AddButton, {
+  }), properties.map(function (prop) {
+    return prop.content;
+  }), utils.canExpand(schema, uiSchema, formData) && /*#__PURE__*/React__default["default"].createElement(AddButton, {
     className: "object-property-expand",
     onClick: onAddClick(schema),
     disabled: disabled || readonly,
@@ -2364,17 +2357,15 @@ function ObjectFieldTemplate(props) {
   }));
 }
 
-const REQUIRED_FIELD_SYMBOL = "*";
+var REQUIRED_FIELD_SYMBOL = "*";
 /** The `TitleField` is the template to use to render the title of a field
  *
  * @param props - The `TitleFieldProps` for this component
  */
 function TitleField(props) {
-  const {
-    id,
-    title,
-    required
-  } = props;
+  var id = props.id,
+    title = props.title,
+    required = props.required;
   return /*#__PURE__*/React__default["default"].createElement("legend", {
     id: id
   }, title, required && /*#__PURE__*/React__default["default"].createElement("span", {
@@ -2388,11 +2379,9 @@ function TitleField(props) {
  * @param props - The `FieldProps` for this template
  */
 function UnsupportedField(props) {
-  const {
-    schema,
-    idSchema,
-    reason
-  } = props;
+  var schema = props.schema,
+    idSchema = props.idSchema,
+    reason = props.reason;
   return /*#__PURE__*/React__default["default"].createElement("div", {
     className: "unsupported-field"
   }, /*#__PURE__*/React__default["default"].createElement("p", null, "Unsupported field schema", idSchema && idSchema.$id && /*#__PURE__*/React__default["default"].createElement("span", null, " for", " field ", /*#__PURE__*/React__default["default"].createElement("code", null, idSchema.$id)), reason && /*#__PURE__*/React__default["default"].createElement("em", null, ": ", reason), "."), schema && /*#__PURE__*/React__default["default"].createElement("pre", null, JSON.stringify(schema, null, 2)));
@@ -2404,26 +2393,22 @@ function UnsupportedField(props) {
  * @param props - The `WrapIfAdditionalProps` for this component
  */
 function WrapIfAdditionalTemplate(props) {
-  const {
-    id,
-    classNames,
-    disabled,
-    label,
-    onKeyChange,
-    onDropPropertyClick,
-    readonly,
-    required,
-    schema,
-    children,
-    uiSchema,
-    registry
-  } = props;
+  var id = props.id,
+    classNames = props.classNames,
+    disabled = props.disabled,
+    label = props.label,
+    onKeyChange = props.onKeyChange,
+    onDropPropertyClick = props.onDropPropertyClick,
+    readonly = props.readonly,
+    required = props.required,
+    schema = props.schema,
+    children = props.children,
+    uiSchema = props.uiSchema,
+    registry = props.registry;
   // Button templates are not overridden in the uiSchema
-  const {
-    RemoveButton
-  } = registry.templates.ButtonTemplates;
-  const keyLabel = `${label} Key`; // i18n ?
-  const additional = (utils.ADDITIONAL_PROPERTY_FLAG in schema);
+  var RemoveButton = registry.templates.ButtonTemplates.RemoveButton;
+  var keyLabel = label + " Key"; // i18n ?
+  var additional = (utils.ADDITIONAL_PROPERTY_FLAG in schema);
   if (!additional) {
     return /*#__PURE__*/React__default["default"].createElement("div", {
       className: classNames
@@ -2440,12 +2425,14 @@ function WrapIfAdditionalTemplate(props) {
   }, /*#__PURE__*/React__default["default"].createElement(Label, {
     label: keyLabel,
     required: required,
-    id: `${id}-key`
+    id: id + "-key"
   }), /*#__PURE__*/React__default["default"].createElement("input", {
     className: "form-control",
     type: "text",
-    id: `${id}-key`,
-    onBlur: event => onKeyChange(event.target.value),
+    id: id + "-key",
+    onBlur: function onBlur(event) {
+      return onKeyChange(event.target.value);
+    },
     defaultValue: label
   }))), /*#__PURE__*/React__default["default"].createElement("div", {
     className: "form-additional form-group col-xs-5"
@@ -2464,27 +2451,27 @@ function WrapIfAdditionalTemplate(props) {
 
 function templates() {
   return {
-    ArrayFieldDescriptionTemplate,
-    ArrayFieldItemTemplate,
-    ArrayFieldTemplate,
-    ArrayFieldTitleTemplate,
+    ArrayFieldDescriptionTemplate: ArrayFieldDescriptionTemplate,
+    ArrayFieldItemTemplate: ArrayFieldItemTemplate,
+    ArrayFieldTemplate: ArrayFieldTemplate,
+    ArrayFieldTitleTemplate: ArrayFieldTitleTemplate,
     ButtonTemplates: buttonTemplates(),
-    BaseInputTemplate,
+    BaseInputTemplate: BaseInputTemplate,
     DescriptionFieldTemplate: DescriptionField,
     ErrorListTemplate: ErrorList,
-    FieldTemplate,
-    FieldErrorTemplate,
-    FieldHelpTemplate,
-    ObjectFieldTemplate,
+    FieldTemplate: FieldTemplate,
+    FieldErrorTemplate: FieldErrorTemplate,
+    FieldHelpTemplate: FieldHelpTemplate,
+    ObjectFieldTemplate: ObjectFieldTemplate,
     TitleFieldTemplate: TitleField,
     UnsupportedFieldTemplate: UnsupportedField,
-    WrapIfAdditionalTemplate
+    WrapIfAdditionalTemplate: WrapIfAdditionalTemplate
   };
 }
 
 function rangeOptions(start, stop) {
-  const options = [];
-  for (let i = start; i <= stop; i++) {
+  var options = [];
+  for (var i = start; i <= stop; i++) {
     options.push({
       value: i,
       label: utils.pad(i, 2)
@@ -2493,21 +2480,21 @@ function rangeOptions(start, stop) {
   return options;
 }
 function readyForChange(state) {
-  return Object.values(state).every(value => value !== -1);
+  return Object.values(state).every(function (value) {
+    return value !== -1;
+  });
 }
 function dateElementProps(state, time, yearsRange) {
   if (yearsRange === void 0) {
     yearsRange = [1900, new Date().getFullYear() + 2];
   }
-  const {
-    year,
-    month,
-    day,
-    hour,
-    minute,
-    second
-  } = state;
-  const data = [{
+  var year = state.year,
+    month = state.month,
+    day = state.day,
+    hour = state.hour,
+    minute = state.minute,
+    second = state.second;
+  var data = [{
     type: "year",
     range: yearsRange,
     value: year
@@ -2538,23 +2525,19 @@ function dateElementProps(state, time, yearsRange) {
   return data;
 }
 function DateElement(_ref) {
-  let {
-    type,
-    range,
-    value,
-    select,
-    rootId,
-    disabled,
-    readonly,
-    autofocus,
-    registry,
-    onBlur,
-    onFocus
-  } = _ref;
-  const id = rootId + "_" + type;
-  const {
-    SelectWidget
-  } = registry.widgets;
+  var type = _ref.type,
+    range = _ref.range,
+    value = _ref.value,
+    select = _ref.select,
+    rootId = _ref.rootId,
+    disabled = _ref.disabled,
+    readonly = _ref.readonly,
+    autofocus = _ref.autofocus,
+    registry = _ref.registry,
+    onBlur = _ref.onBlur,
+    onFocus = _ref.onFocus;
+  var id = rootId + "_" + type;
+  var SelectWidget = registry.widgets.SelectWidget;
   return /*#__PURE__*/React__default["default"].createElement(SelectWidget, {
     schema: {
       type: "integer"
@@ -2569,7 +2552,9 @@ function DateElement(_ref) {
     disabled: disabled,
     readonly: readonly,
     autofocus: autofocus,
-    onChange: value => select(type, value),
+    onChange: function onChange(value) {
+      return select(type, value);
+    },
     onBlur: onBlur,
     onFocus: onFocus,
     registry: registry,
@@ -2580,50 +2565,50 @@ function DateElement(_ref) {
  * @param props - The `WidgetProps` for this component
  */
 function AltDateWidget(_ref2) {
-  let {
-    time = false,
-    disabled = false,
-    readonly = false,
-    autofocus = false,
-    options,
-    id,
-    registry,
-    onBlur,
-    onFocus,
-    onChange,
-    value
-  } = _ref2;
-  const [state, setState] = React.useReducer((state, action) => {
-    return {
-      ...state,
-      ...action
-    };
-  }, utils.parseDateString(value, time));
-  React.useEffect(() => {
+  var _ref2$time = _ref2.time,
+    time = _ref2$time === void 0 ? false : _ref2$time,
+    _ref2$disabled = _ref2.disabled,
+    disabled = _ref2$disabled === void 0 ? false : _ref2$disabled,
+    _ref2$readonly = _ref2.readonly,
+    readonly = _ref2$readonly === void 0 ? false : _ref2$readonly,
+    _ref2$autofocus = _ref2.autofocus,
+    autofocus = _ref2$autofocus === void 0 ? false : _ref2$autofocus,
+    options = _ref2.options,
+    id = _ref2.id,
+    registry = _ref2.registry,
+    onBlur = _ref2.onBlur,
+    onFocus = _ref2.onFocus,
+    onChange = _ref2.onChange,
+    value = _ref2.value;
+  var _useReducer = React.useReducer(function (state, action) {
+      return _extends({}, state, action);
+    }, utils.parseDateString(value, time)),
+    state = _useReducer[0],
+    setState = _useReducer[1];
+  React.useEffect(function () {
     if (value && value !== utils.toDateString(state, time)) {
       setState(utils.parseDateString(value, time));
     }
   }, [value, state, time]);
-  React.useEffect(() => {
+  React.useEffect(function () {
     if (readyForChange(state)) {
       // Only propagate to parent state if we have a complete date{time}
       onChange(utils.toDateString(state, time));
     }
   }, [state, time, onChange]);
-  const handleChange = React.useCallback((property, value) => {
-    setState({
-      [property]: value
-    });
+  var handleChange = React.useCallback(function (property, value) {
+    var _setState;
+    setState((_setState = {}, _setState[property] = value, _setState));
   }, []);
-  const handleSetNow = React.useCallback(event => {
+  var handleSetNow = React.useCallback(function (event) {
     event.preventDefault();
     if (disabled || readonly) {
       return;
     }
-    const nowDateObj = utils.parseDateString(new Date().toJSON(), time);
+    var nowDateObj = utils.parseDateString(new Date().toJSON(), time);
     setState(nowDateObj);
   }, [disabled, readonly, time]);
-  const handleClear = React.useCallback(event => {
+  var handleClear = React.useCallback(function (event) {
     event.preventDefault();
     if (disabled || readonly) {
       return;
@@ -2633,19 +2618,21 @@ function AltDateWidget(_ref2) {
   }, [disabled, readonly, time, onChange]);
   return /*#__PURE__*/React__default["default"].createElement("ul", {
     className: "list-inline"
-  }, dateElementProps(state, time, options.yearsRange).map((elemProps, i) => /*#__PURE__*/React__default["default"].createElement("li", {
-    key: i
-  }, /*#__PURE__*/React__default["default"].createElement(DateElement, {
-    rootId: id,
-    select: handleChange,
-    ...elemProps,
-    disabled: disabled,
-    readonly: readonly,
-    registry: registry,
-    onBlur: onBlur,
-    onFocus: onFocus,
-    autofocus: autofocus && i === 0
-  }))), (options.hideNowButton !== "undefined" ? !options.hideNowButton : true) && /*#__PURE__*/React__default["default"].createElement("li", null, /*#__PURE__*/React__default["default"].createElement("a", {
+  }, dateElementProps(state, time, options.yearsRange).map(function (elemProps, i) {
+    return /*#__PURE__*/React__default["default"].createElement("li", {
+      key: i
+    }, /*#__PURE__*/React__default["default"].createElement(DateElement, _extends({
+      rootId: id,
+      select: handleChange
+    }, elemProps, {
+      disabled: disabled,
+      readonly: readonly,
+      registry: registry,
+      onBlur: onBlur,
+      onFocus: onFocus,
+      autofocus: autofocus && i === 0
+    })));
+  }), (options.hideNowButton !== "undefined" ? !options.hideNowButton : true) && /*#__PURE__*/React__default["default"].createElement("li", null, /*#__PURE__*/React__default["default"].createElement("a", {
     href: "#",
     className: "btn btn-info btn-now",
     onClick: handleSetNow
@@ -2656,23 +2643,20 @@ function AltDateWidget(_ref2) {
   }, "Clear")));
 }
 
+var _excluded$1 = ["time"];
 /** The `AltDateTimeWidget` is an alternative widget for rendering datetime properties.
  *  It uses the AltDateWidget for rendering, with the `time` prop set to true by default.
  *
  * @param props - The `WidgetProps` for this component
  */
 function AltDateTimeWidget(_ref) {
-  let {
-    time = true,
-    ...props
-  } = _ref;
-  const {
-    AltDateWidget
-  } = props.registry.widgets;
-  return /*#__PURE__*/React__default["default"].createElement(AltDateWidget, {
-    time: time,
-    ...props
-  });
+  var _ref$time = _ref.time,
+    time = _ref$time === void 0 ? true : _ref$time,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded$1);
+  var AltDateWidget = props.registry.widgets.AltDateWidget;
+  return /*#__PURE__*/React__default["default"].createElement(AltDateWidget, _extends({
+    time: time
+  }, props));
 }
 
 /** The `CheckBoxWidget` is a widget for rendering boolean properties.
@@ -2681,31 +2665,36 @@ function AltDateTimeWidget(_ref) {
  * @param props - The `WidgetProps` for this component
  */
 function CheckboxWidget(_ref) {
-  let {
-    schema,
-    uiSchema,
-    options,
-    id,
-    value,
-    disabled,
-    readonly,
-    label,
-    autofocus = false,
-    onBlur,
-    onFocus,
-    onChange,
-    registry
-  } = _ref;
-  const DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, options);
+  var schema = _ref.schema,
+    uiSchema = _ref.uiSchema,
+    options = _ref.options,
+    id = _ref.id,
+    value = _ref.value,
+    disabled = _ref.disabled,
+    readonly = _ref.readonly,
+    label = _ref.label,
+    _ref$autofocus = _ref.autofocus,
+    autofocus = _ref$autofocus === void 0 ? false : _ref$autofocus,
+    onBlur = _ref.onBlur,
+    onFocus = _ref.onFocus,
+    onChange = _ref.onChange,
+    registry = _ref.registry;
+  var DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, options);
   // Because an unchecked checkbox will cause html5 validation to fail, only add
   // the "required" attribute if the field value must be "true", due to the
   // "const" or "enum" keywords
-  const required = utils.schemaRequiresTrueValue(schema);
-  const handleChange = React.useCallback(event => onChange(event.target.checked), [onChange]);
-  const handleBlur = React.useCallback(event => onBlur(id, event.target.checked), [onBlur, id]);
-  const handleFocus = React.useCallback(event => onFocus(id, event.target.checked), [onFocus, id]);
+  var required = utils.schemaRequiresTrueValue(schema);
+  var handleChange = React.useCallback(function (event) {
+    return onChange(event.target.checked);
+  }, [onChange]);
+  var handleBlur = React.useCallback(function (event) {
+    return onBlur(id, event.target.checked);
+  }, [onBlur, id]);
+  var handleFocus = React.useCallback(function (event) {
+    return onFocus(id, event.target.checked);
+  }, [onFocus, id]);
   return /*#__PURE__*/React__default["default"].createElement("div", {
-    className: `checkbox ${disabled || readonly ? "disabled" : ""}`
+    className: "checkbox " + (disabled || readonly ? "disabled" : "")
   }, schema.description && /*#__PURE__*/React__default["default"].createElement(DescriptionFieldTemplate, {
     id: id + "__description",
     description: schema.description,
@@ -2727,14 +2716,18 @@ function CheckboxWidget(_ref) {
 }
 
 function selectValue(value, selected, all) {
-  const at = all.indexOf(value);
-  const updated = selected.slice(0, at).concat(value, selected.slice(at));
+  var at = all.indexOf(value);
+  var updated = selected.slice(0, at).concat(value, selected.slice(at));
   // 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((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
+  return updated.sort(function (a, b) {
+    return Number(all.indexOf(a) > all.indexOf(b));
+  });
 }
 function deselectValue(value, selected) {
-  return selected.filter(v => v !== value);
+  return selected.filter(function (v) {
+    return v !== value;
+  });
 }
 /** The `CheckboxesWidget` is a widget for rendering checkbox groups.
  *  It is typically used to represent an array of enums.
@@ -2742,31 +2735,28 @@ function deselectValue(value, selected) {
  * @param props - The `WidgetProps` for this component
  */
 function CheckboxesWidget(_ref) {
-  let {
-    id,
-    disabled,
-    options: {
-      inline = false,
-      enumOptions,
-      enumDisabled
-    },
-    value,
-    autofocus = false,
-    readonly,
-    onChange
-  } = _ref;
+  var id = _ref.id,
+    disabled = _ref.disabled,
+    _ref$options = _ref.options,
+    _ref$options$inline = _ref$options.inline,
+    inline = _ref$options$inline === void 0 ? false : _ref$options$inline,
+    enumOptions = _ref$options.enumOptions,
+    enumDisabled = _ref$options.enumDisabled,
+    value = _ref.value,
+    _ref$autofocus = _ref.autofocus,
+    autofocus = _ref$autofocus === void 0 ? false : _ref$autofocus,
+    readonly = _ref.readonly,
+    onChange = _ref.onChange;
   return /*#__PURE__*/React__default["default"].createElement("div", {
     className: "checkboxes",
     id: id
-  }, Array.isArray(enumOptions) && enumOptions.map((option, index) => {
-    const checked = value.indexOf(option.value) !== -1;
-    const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) != -1;
-    const disabledCls = disabled || itemDisabled || readonly ? "disabled" : "";
-    const handleChange = event => {
-      const all = enumOptions.map(_ref2 => {
-        let {
-          value
-        } = _ref2;
+  }, Array.isArray(enumOptions) && enumOptions.map(function (option, index) {
+    var checked = value.indexOf(option.value) !== -1;
+    var itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) != -1;
+    var disabledCls = disabled || itemDisabled || readonly ? "disabled" : "";
+    var handleChange = function handleChange(event) {
+      var all = enumOptions.map(function (_ref2) {
+        var value = _ref2.value;
         return value;
       });
       if (event.target.checked) {
@@ -2775,9 +2765,9 @@ function CheckboxesWidget(_ref) {
         onChange(deselectValue(option.value, value));
       }
     };
-    const checkbox = /*#__PURE__*/React__default["default"].createElement("span", null, /*#__PURE__*/React__default["default"].createElement("input", {
+    var checkbox = /*#__PURE__*/React__default["default"].createElement("span", null, /*#__PURE__*/React__default["default"].createElement("input", {
       type: "checkbox",
-      id: `${id}-${option.value}`,
+      id: id + "-" + option.value,
       name: id,
       checked: checked,
       disabled: disabled || itemDisabled || readonly,
@@ -2786,10 +2776,10 @@ function CheckboxesWidget(_ref) {
     }), /*#__PURE__*/React__default["default"].createElement("span", null, option.label));
     return inline ? /*#__PURE__*/React__default["default"].createElement("label", {
       key: option.value,
-      className: `checkbox-inline ${disabledCls}`
+      className: "checkbox-inline " + disabledCls
     }, checkbox) : /*#__PURE__*/React__default["default"].createElement("div", {
       key: option.value,
-      className: `checkbox ${disabledCls}`
+      className: "checkbox " + disabledCls
     }, /*#__PURE__*/React__default["default"].createElement("label", null, checkbox));
   }));
 }
@@ -2800,18 +2790,16 @@ function CheckboxesWidget(_ref) {
  * @param props - The `WidgetProps` for this component
  */
 function ColorWidget(props) {
-  const {
-    disabled,
-    readonly,
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "color",
-    ...props,
+  var disabled = props.disabled,
+    readonly = props.readonly,
+    options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "color"
+  }, props, {
     disabled: disabled || readonly
-  });
+  }));
 }
 
 /** The `DateWidget` component uses the `BaseInputTemplate` changing the type to `date` and transforms
@@ -2820,18 +2808,18 @@ function ColorWidget(props) {
  * @param props - The `WidgetProps` for this component
  */
 function DateWidget(props) {
-  const {
-    onChange,
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  const handleChange = React.useCallback(value => onChange(value || undefined), [onChange]);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "date",
-    ...props,
+  var onChange = props.onChange,
+    options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  var handleChange = React.useCallback(function (value) {
+    return onChange(value || undefined);
+  }, [onChange]);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "date"
+  }, props, {
     onChange: handleChange
-  });
+  }));
 }
 
 /** The `DateTimeWidget` component uses the `BaseInputTemplate` changing the type to `datetime-local` and transforms
@@ -2840,19 +2828,19 @@ function DateWidget(props) {
  * @param props - The `WidgetProps` for this component
  */
 function DateTimeWidget(props) {
-  const {
-    onChange,
-    value,
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "datetime-local",
-    ...props,
+  var _onChange = props.onChange,
+    value = props.value,
+    options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "datetime-local"
+  }, props, {
     value: utils.utcToLocal(value),
-    onChange: value => onChange(utils.localToUTC(value))
-  });
+    onChange: function onChange(value) {
+      return _onChange(utils.localToUTC(value));
+    }
+  }));
 }
 
 /** The `EmailWidget` component uses the `BaseInputTemplate` changing the type to `email`.
@@ -2860,47 +2848,42 @@ function DateTimeWidget(props) {
  * @param props - The `WidgetProps` for this component
  */
 function EmailWidget(props) {
-  const {
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "email",
-    ...props
-  });
+  var options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "email"
+  }, props));
 }
 
 function addNameToDataURL(dataURL, name) {
   if (dataURL === null) {
     return null;
   }
-  return dataURL.replace(";base64", `;name=${encodeURIComponent(name)};base64`);
+  return dataURL.replace(";base64", ";name=" + encodeURIComponent(name) + ";base64");
 }
 function processFile(file) {
-  const {
-    name,
-    size,
-    type
-  } = file;
-  return new Promise((resolve, reject) => {
-    const reader = new window.FileReader();
+  var name = file.name,
+    size = file.size,
+    type = file.type;
+  return new Promise(function (resolve, reject) {
+    var reader = new window.FileReader();
     reader.onerror = reject;
-    reader.onload = event => {
+    reader.onload = function (event) {
       var _event$target;
       if (typeof ((_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.result) === "string") {
         resolve({
           dataURL: addNameToDataURL(event.target.result, name),
-          name,
-          size,
-          type
+          name: name,
+          size: size,
+          type: type
         });
       } else {
         resolve({
           dataURL: null,
-          name,
-          size,
-          type
+          name: name,
+          size: size,
+          type: type
         });
       }
     };
@@ -2911,31 +2894,28 @@ function processFiles(files) {
   return Promise.all(Array.from(files).map(processFile));
 }
 function FilesInfo(_ref) {
-  let {
-    filesInfo
-  } = _ref;
+  var filesInfo = _ref.filesInfo;
   if (filesInfo.length === 0) {
     return null;
   }
   return /*#__PURE__*/React__default["default"].createElement("ul", {
     className: "file-info"
-  }, filesInfo.map((fileInfo, key) => {
-    const {
-      name,
-      size,
-      type
-    } = fileInfo;
+  }, filesInfo.map(function (fileInfo, key) {
+    var name = fileInfo.name,
+      size = fileInfo.size,
+      type = fileInfo.type;
     return /*#__PURE__*/React__default["default"].createElement("li", {
       key: key
     }, /*#__PURE__*/React__default["default"].createElement("strong", null, name), " (", type, ", ", size, " bytes)");
   }));
 }
 function extractFileInfo(dataURLs) {
-  return dataURLs.filter(dataURL => typeof dataURL !== "undefined").map(dataURL => {
-    const {
-      blob,
-      name
-    } = utils.dataURItoBlob(dataURL);
+  return dataURLs.filter(function (dataURL) {
+    return typeof dataURL !== "undefined";
+  }).map(function (dataURL) {
+    var _dataURItoBlob = utils.dataURItoBlob(dataURL),
+      blob = _dataURItoBlob.blob,
+      name = _dataURItoBlob.name;
     return {
       name: name,
       size: blob.size,
@@ -2948,25 +2928,30 @@ function extractFileInfo(dataURLs) {
  *  It is typically used with a string property with data-url format.
  */
 function FileWidget(_ref2) {
-  let {
-    multiple,
-    id,
-    readonly,
-    disabled,
-    onChange,
-    value,
-    autofocus = false,
-    options
-  } = _ref2;
-  const extractedFilesInfo = React.useMemo(() => Array.isArray(value) ? extractFileInfo(value) : extractFileInfo([value]), [value]);
-  const [filesInfo, setFilesInfo] = React.useState(extractedFilesInfo);
-  const handleChange = React.useCallback(event => {
+  var multiple = _ref2.multiple,
+    id = _ref2.id,
+    readonly = _ref2.readonly,
+    disabled = _ref2.disabled,
+    onChange = _ref2.onChange,
+    value = _ref2.value,
+    _ref2$autofocus = _ref2.autofocus,
+    autofocus = _ref2$autofocus === void 0 ? false : _ref2$autofocus,
+    options = _ref2.options;
+  var extractedFilesInfo = React.useMemo(function () {
+    return Array.isArray(value) ? extractFileInfo(value) : extractFileInfo([value]);
+  }, [value]);
+  var _useState = React.useState(extractedFilesInfo),
+    filesInfo = _useState[0],
+    setFilesInfo = _useState[1];
+  var handleChange = React.useCallback(function (event) {
     if (!event.target.files) {
       return;
     }
-    processFiles(event.target.files).then(filesInfoEvent => {
+    processFiles(event.target.files).then(function (filesInfoEvent) {
       setFilesInfo(filesInfoEvent);
-      const newValue = filesInfoEvent.map(fileInfo => fileInfo.dataURL);
+      var newValue = filesInfoEvent.map(function (fileInfo) {
+        return fileInfo.dataURL;
+      });
       if (multiple) {
         onChange(newValue);
       } else {
@@ -2995,10 +2980,8 @@ function FileWidget(_ref2) {
  * @param props - The `WidgetProps` for this component
  */
 function HiddenWidget(_ref) {
-  let {
-    id,
-    value
-  } = _ref;
+  var id = _ref.id,
+    value = _ref.value;
   return /*#__PURE__*/React__default["default"].createElement("input", {
     type: "hidden",
     id: id,
@@ -3012,15 +2995,12 @@ function HiddenWidget(_ref) {
  * @param props - The `WidgetProps` for this component
  */
 function PasswordWidget(props) {
-  const {
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "password",
-    ...props
-  });
+  var options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "password"
+  }, props));
 }
 
 /** The `RadioWidget` is a widget for rendering a radio group.
@@ -3029,40 +3009,43 @@ function PasswordWidget(props) {
  * @param props - The `WidgetProps` for this component
  */
 function RadioWidget(_ref) {
-  let {
-    options,
-    value,
-    required,
-    disabled,
-    readonly,
-    autofocus = false,
-    onBlur,
-    onFocus,
-    onChange,
-    id
-  } = _ref;
+  var options = _ref.options,
+    value = _ref.value,
+    required = _ref.required,
+    disabled = _ref.disabled,
+    readonly = _ref.readonly,
+    _ref$autofocus = _ref.autofocus,
+    autofocus = _ref$autofocus === void 0 ? false : _ref$autofocus,
+    onBlur = _ref.onBlur,
+    onFocus = _ref.onFocus,
+    onChange = _ref.onChange,
+    id = _ref.id;
   // Generating a unique field name to identify this set of radio buttons
-  const name = Math.random().toString();
-  const {
-    enumOptions,
-    enumDisabled,
-    inline
-  } = options;
+  var name = Math.random().toString();
+  var enumOptions = options.enumOptions,
+    enumDisabled = options.enumDisabled,
+    inline = options.inline;
   // checked={checked} has been moved above name={name}, As mentioned in #349;
   // this is a temporary fix for radio button rendering bug in React, facebook/react#7630.
-  const handleBlur = React.useCallback(event => onBlur(id, event.target.value), [onBlur, id]);
-  const handleFocus = React.useCallback(event => onFocus(id, event.target.value), [onFocus, id]);
+  var handleBlur = React.useCallback(function (event) {
+    return onBlur(id, event.target.value);
+  }, [onBlur, id]);
+  var handleFocus = React.useCallback(function (event) {
+    return onFocus(id, event.target.value);
+  }, [onFocus, id]);
   return /*#__PURE__*/React__default["default"].createElement("div", {
     className: "field-radio-group",
     id: id
-  }, Array.isArray(enumOptions) && enumOptions.map((option, i) => {
-    const checked = option.value === value;
-    const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) != -1;
-    const disabledCls = disabled || itemDisabled || readonly ? "disabled" : "";
-    const handleChange = () => onChange(option.value);
-    const radio = /*#__PURE__*/React__default["default"].createElement("span", null, /*#__PURE__*/React__default["default"].createElement("input", {
+  }, Array.isArray(enumOptions) && enumOptions.map(function (option, i) {
+    var checked = option.value === value;
+    var itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) != -1;
+    var disabledCls = disabled || itemDisabled || readonly ? "disabled" : "";
+    var handleChange = function handleChange() {
+      return onChange(option.value);
+    };
+    var radio = /*#__PURE__*/React__default["default"].createElement("span", null, /*#__PURE__*/React__default["default"].createElement("input", {
       type: "radio",
-      id: `${id}-${option.value}`,
+      id: id + "-" + option.value,
       checked: checked,
       name: name,
       required: required,
@@ -3075,10 +3058,10 @@ function RadioWidget(_ref) {
     }), /*#__PURE__*/React__default["default"].createElement("span", null, option.label));
     return inline ? /*#__PURE__*/React__default["default"].createElement("label", {
       key: option.value,
-      className: `radio-inline ${disabledCls}`
+      className: "radio-inline " + disabledCls
     }, radio) : /*#__PURE__*/React__default["default"].createElement("div", {
       key: option.value,
-      className: `radio ${disabledCls}`
+      className: "radio " + disabledCls
     }, /*#__PURE__*/React__default["default"].createElement("label", null, radio));
   }));
 }
@@ -3089,27 +3072,24 @@ function RadioWidget(_ref) {
  * @param props - The `WidgetProps` for this component
  */
 function RangeWidget(props) {
-  const {
-    value,
-    registry: {
-      templates: {
-        BaseInputTemplate
-      }
-    }
-  } = props;
+  var value = props.value,
+    BaseInputTemplate = props.registry.templates.BaseInputTemplate;
   return /*#__PURE__*/React__default["default"].createElement("div", {
     className: "field-range-wrapper"
-  }, /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "range",
-    ...props
-  }), /*#__PURE__*/React__default["default"].createElement("span", {
+  }, /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "range"
+  }, props)), /*#__PURE__*/React__default["default"].createElement("span", {
     className: "range-view"
   }, value));
 }
 
 function getValue(event, multiple) {
   if (multiple) {
-    return Array.from(event.target.options).slice().filter(o => o.selected).map(o => o.value);
+    return Array.from(event.target.options).slice().filter(function (o) {
+      return o.selected;
+    }).map(function (o) {
+      return o.value;
+    });
   }
   return event.target.value;
 }
@@ -3119,36 +3099,34 @@ function getValue(event, multiple) {
  * @param props - The `WidgetProps` for this component
  */
 function SelectWidget(_ref) {
-  let {
-    schema,
-    id,
-    options,
-    value,
-    required,
-    disabled,
-    readonly,
-    multiple = false,
-    autofocus = false,
-    onChange,
-    onBlur,
-    onFocus,
-    placeholder
-  } = _ref;
-  const {
-    enumOptions,
-    enumDisabled
-  } = options;
-  const emptyValue = multiple ? [] : "";
-  const handleFocus = React.useCallback(event => {
-    const newValue = getValue(event, multiple);
+  var schema = _ref.schema,
+    id = _ref.id,
+    options = _ref.options,
+    value = _ref.value,
+    required = _ref.required,
+    disabled = _ref.disabled,
+    readonly = _ref.readonly,
+    _ref$multiple = _ref.multiple,
+    multiple = _ref$multiple === void 0 ? false : _ref$multiple,
+    _ref$autofocus = _ref.autofocus,
+    autofocus = _ref$autofocus === void 0 ? false : _ref$autofocus,
+    onChange = _ref.onChange,
+    onBlur = _ref.onBlur,
+    onFocus = _ref.onFocus,
+    placeholder = _ref.placeholder;
+  var enumOptions = options.enumOptions,
+    enumDisabled = options.enumDisabled;
+  var emptyValue = multiple ? [] : "";
+  var handleFocus = React.useCallback(function (event) {
+    var newValue = getValue(event, multiple);
     return onFocus(id, utils.processSelectValue(schema, newValue, options));
   }, [onFocus, id, schema, multiple, options]);
-  const handleBlur = React.useCallback(event => {
-    const newValue = getValue(event, multiple);
+  var handleBlur = React.useCallback(function (event) {
+    var newValue = getValue(event, multiple);
     return onBlur(id, utils.processSelectValue(schema, newValue, options));
   }, [onBlur, id, schema, multiple, options]);
-  const handleChange = React.useCallback(event => {
-    const newValue = getValue(event, multiple);
+  var handleChange = React.useCallback(function (event) {
+    var newValue = getValue(event, multiple);
     return onChange(utils.processSelectValue(schema, newValue, options));
   }, [onChange, schema, multiple, options]);
   return /*#__PURE__*/React__default["default"].createElement("select", {
@@ -3163,14 +3141,12 @@ function SelectWidget(_ref) {
     onBlur: handleBlur,
     onFocus: handleFocus,
     onChange: handleChange
-  }, !multiple && schema.default === undefined && /*#__PURE__*/React__default["default"].createElement("option", {
+  }, !multiple && schema["default"] === undefined && /*#__PURE__*/React__default["default"].createElement("option", {
     value: ""
-  }, placeholder), Array.isArray(enumOptions) && enumOptions.map((_ref2, i) => {
-    let {
-      value,
-      label
-    } = _ref2;
-    const disabled = enumDisabled && enumDisabled.indexOf(value) != -1;
+  }, placeholder), Array.isArray(enumOptions) && enumOptions.map(function (_ref2, i) {
+    var value = _ref2.value,
+      label = _ref2.label;
+    var disabled = enumDisabled && enumDisabled.indexOf(value) != -1;
     return /*#__PURE__*/React__default["default"].createElement("option", {
       key: i,
       value: value,
@@ -3184,41 +3160,29 @@ function SelectWidget(_ref) {
  * @param props - The `WidgetProps` for this component
  */
 function TextareaWidget(_ref) {
-  let {
-    id,
-    options = {},
-    placeholder,
-    value,
-    required,
-    disabled,
-    readonly,
-    autofocus = false,
-    onChange,
-    onBlur,
-    onFocus
-  } = _ref;
-  const handleChange = React.useCallback(_ref2 => {
-    let {
-      target: {
-        value
-      }
-    } = _ref2;
+  var id = _ref.id,
+    _ref$options = _ref.options,
+    options = _ref$options === void 0 ? {} : _ref$options,
+    placeholder = _ref.placeholder,
+    value = _ref.value,
+    required = _ref.required,
+    disabled = _ref.disabled,
+    readonly = _ref.readonly,
+    _ref$autofocus = _ref.autofocus,
+    autofocus = _ref$autofocus === void 0 ? false : _ref$autofocus,
+    onChange = _ref.onChange,
+    onBlur = _ref.onBlur,
+    onFocus = _ref.onFocus;
+  var handleChange = React.useCallback(function (_ref2) {
+    var value = _ref2.target.value;
     return onChange(value === "" ? options.emptyValue : value);
   }, [onChange, options.emptyValue]);
-  const handleBlur = React.useCallback(_ref3 => {
-    let {
-      target: {
-        value
-      }
-    } = _ref3;
+  var handleBlur = React.useCallback(function (_ref3) {
+    var value = _ref3.target.value;
     return onBlur(id, value);
   }, [onBlur, id]);
-  const handleFocus = React.useCallback(_ref4 => {
-    let {
-      target: {
-        value
-      }
-    } = _ref4;
+  var handleFocus = React.useCallback(function (_ref4) {
+    var value = _ref4.target.value;
     return onFocus(id, value);
   }, [id, onFocus]);
   return /*#__PURE__*/React__default["default"].createElement("textarea", {
@@ -3247,14 +3211,10 @@ TextareaWidget.defaultProps = {
  * @param props - The `WidgetProps` for this component
  */
 function TextWidget(props) {
-  const {
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    ...props
-  });
+  var options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({}, props));
 }
 
 /** The `URLWidget` component uses the `BaseInputTemplate` changing the type to `url`.
@@ -3262,15 +3222,12 @@ function TextWidget(props) {
  * @param props - The `WidgetProps` for this component
  */
 function URLWidget(props) {
-  const {
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "url",
-    ...props
-  });
+  var options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "url"
+  }, props));
 }
 
 /** The `UpDownWidget` component uses the `BaseInputTemplate` changing the type to `number`.
@@ -3278,37 +3235,34 @@ function URLWidget(props) {
  * @param props - The `WidgetProps` for this component
  */
 function UpDownWidget(props) {
-  const {
-    options,
-    registry
-  } = props;
-  const BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
-  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, {
-    type: "number",
-    ...props
-  });
+  var options = props.options,
+    registry = props.registry;
+  var BaseInputTemplate = utils.getTemplate("BaseInputTemplate", registry, options);
+  return /*#__PURE__*/React__default["default"].createElement(BaseInputTemplate, _extends({
+    type: "number"
+  }, props));
 }
 
 function widgets() {
   return {
-    PasswordWidget,
-    RadioWidget,
-    UpDownWidget,
-    RangeWidget,
-    SelectWidget,
-    TextWidget,
-    DateWidget,
-    DateTimeWidget,
-    AltDateWidget,
-    AltDateTimeWidget,
-    EmailWidget,
-    URLWidget,
-    TextareaWidget,
-    HiddenWidget,
-    ColorWidget,
-    FileWidget,
-    CheckboxWidget,
-    CheckboxesWidget
+    PasswordWidget: PasswordWidget,
+    RadioWidget: RadioWidget,
+    UpDownWidget: UpDownWidget,
+    RangeWidget: RangeWidget,
+    SelectWidget: SelectWidget,
+    TextWidget: TextWidget,
+    DateWidget: DateWidget,
+    DateTimeWidget: DateTimeWidget,
+    AltDateWidget: AltDateWidget,
+    AltDateTimeWidget: AltDateTimeWidget,
+    EmailWidget: EmailWidget,
+    URLWidget: URLWidget,
+    TextareaWidget: TextareaWidget,
+    HiddenWidget: HiddenWidget,
+    ColorWidget: ColorWidget,
+    FileWidget: FileWidget,
+    CheckboxWidget: CheckboxWidget,
+    CheckboxesWidget: CheckboxesWidget
   };
 }
 
@@ -3327,7 +3281,8 @@ function getDefaultRegistry() {
 }
 
 /** The `Form` component renders the outer form and all the fields defined in the `schema` */
-class Form extends React.Component {
+var Form = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(Form, _Component);
   /** The ref used to hold the `form` element, this needs to be `any` because `tagName` or `_internalFormWrapper` can
    * provide any possible type here
    */
@@ -3338,32 +3293,37 @@ class Form extends React.Component {
    *
    * @param props - The initial props for the `Form`
    */
-  constructor(props) {
-    super(props);
-    this.formElement = void 0;
-    this.getUsedFormData = (formData, fields) => {
+  function Form(props) {
+    var _this;
+    _this = _Component.call(this, props) || this;
+    _this.formElement = void 0;
+    _this.getUsedFormData = function (formData, fields) {
       // For the case of a single input form
       if (fields.length === 0 && typeof formData !== "object") {
         return formData;
       }
       // _pick has incorrect type definition, it works with string[][], because lodash/hasIn supports it
-      const data = _pick__default["default"](formData, fields);
+      var data = _pick__default["default"](formData, fields);
       if (Array.isArray(formData)) {
-        return Object.keys(data).map(key => data[key]);
+        return Object.keys(data).map(function (key) {
+          return data[key];
+        });
       }
       return data;
     };
-    this.getFieldNames = (pathSchema, formData) => {
-      const getAllPaths = function (_obj, acc, paths) {
+    _this.getFieldNames = function (pathSchema, formData) {
+      var getAllPaths = function getAllPaths(_obj, acc, paths) {
         if (acc === void 0) {
           acc = [];
         }
         if (paths === void 0) {
           paths = [[]];
         }
-        Object.keys(_obj).forEach(key => {
+        Object.keys(_obj).forEach(function (key) {
           if (typeof _obj[key] === "object") {
-            const newPaths = paths.map(path => [...path, key]);
+            var newPaths = paths.map(function (path) {
+              return [].concat(path, [key]);
+            });
             // If an object is marked with additionalProperties, all its keys are valid
             if (_obj[key][utils.RJSF_ADDITONAL_PROPERTIES_FLAG] && _obj[key][utils.NAME_KEY] !== "") {
               acc.push(_obj[key][utils.NAME_KEY]);
@@ -3371,8 +3331,8 @@ class Form extends React.Component {
               getAllPaths(_obj[key], acc, newPaths);
             }
           } else if (key === utils.NAME_KEY && _obj[key] !== "") {
-            paths.forEach(path => {
-              const formValue = get__default["default"](formData, path);
+            paths.forEach(function (path) {
+              var formValue = get__default["default"](formData, path);
               // adds path to fieldNames if it points to a value
               // or an empty object/array
               if (typeof formValue !== "object" || _isEmpty__default["default"](formValue)) {
@@ -3385,128 +3345,116 @@ class Form extends React.Component {
       };
       return getAllPaths(pathSchema);
     };
-    this.onChange = (formData, newErrorSchema, id) => {
-      const {
-        extraErrors,
-        omitExtraData,
-        liveOmit,
-        noValidate,
-        liveValidate,
-        onChange
-      } = this.props;
-      const {
-        schemaUtils,
-        schema
-      } = this.state;
+    _this.onChange = function (formData, newErrorSchema, id) {
+      var _this$props = _this.props,
+        extraErrors = _this$props.extraErrors,
+        omitExtraData = _this$props.omitExtraData,
+        liveOmit = _this$props.liveOmit,
+        noValidate = _this$props.noValidate,
+        liveValidate = _this$props.liveValidate,
+        onChange = _this$props.onChange;
+      var _this$state = _this.state,
+        schemaUtils = _this$state.schemaUtils,
+        schema = _this$state.schema;
       if (utils.isObject(formData) || Array.isArray(formData)) {
-        const newState = this.getStateFromProps(this.props, formData);
+        var newState = _this.getStateFromProps(_this.props, formData);
         formData = newState.formData;
       }
-      const mustValidate = !noValidate && liveValidate;
-      let state = {
-        formData,
-        schema
+      var mustValidate = !noValidate && liveValidate;
+      var state = {
+        formData: formData,
+        schema: schema
       };
-      let newFormData = formData;
+      var newFormData = formData;
       if (omitExtraData === true && liveOmit === true) {
-        const retrievedSchema = schemaUtils.retrieveSchema(schema, formData);
-        const pathSchema = schemaUtils.toPathSchema(retrievedSchema, "", formData);
-        const fieldNames = this.getFieldNames(pathSchema, formData);
-        newFormData = this.getUsedFormData(formData, fieldNames);
+        var retrievedSchema = schemaUtils.retrieveSchema(schema, formData);
+        var pathSchema = schemaUtils.toPathSchema(retrievedSchema, "", formData);
+        var fieldNames = _this.getFieldNames(pathSchema, formData);
+        newFormData = _this.getUsedFormData(formData, fieldNames);
         state = {
           formData: newFormData
         };
       }
       if (mustValidate) {
-        const schemaValidation = this.validate(newFormData);
-        let errors = schemaValidation.errors;
-        let errorSchema = schemaValidation.errorSchema;
-        const schemaValidationErrors = errors;
-        const schemaValidationErrorSchema = errorSchema;
+        var schemaValidation = _this.validate(newFormData);
+        var errors = schemaValidation.errors;
+        var errorSchema = schemaValidation.errorSchema;
+        var schemaValidationErrors = errors;
+        var schemaValidationErrorSchema = errorSchema;
         if (extraErrors) {
-          const merged = schemaUtils.mergeValidationData(schemaValidation, extraErrors);
+          var merged = schemaUtils.mergeValidationData(schemaValidation, extraErrors);
           errorSchema = merged.errorSchema;
           errors = merged.errors;
         }
         state = {
           formData: newFormData,
-          errors,
-          errorSchema,
-          schemaValidationErrors,
-          schemaValidationErrorSchema
+          errors: errors,
+          errorSchema: errorSchema,
+          schemaValidationErrors: schemaValidationErrors,
+          schemaValidationErrorSchema: schemaValidationErrorSchema
         };
       } else if (!noValidate && newErrorSchema) {
-        const errorSchema = extraErrors ? utils.mergeObjects(newErrorSchema, extraErrors, "preventDuplicates") : newErrorSchema;
+        var _errorSchema = extraErrors ? utils.mergeObjects(newErrorSchema, extraErrors, "preventDuplicates") : newErrorSchema;
         state = {
           formData: newFormData,
-          errorSchema: errorSchema,
-          errors: schemaUtils.getValidator().toErrorList(errorSchema)
+          errorSchema: _errorSchema,
+          errors: schemaUtils.getValidator().toErrorList(_errorSchema)
         };
       }
-      this.setState(state, () => onChange && onChange({
-        ...this.state,
-        ...state
-      }, id));
+      _this.setState(state, function () {
+        return onChange && onChange(_extends({}, _this.state, state), id);
+      });
     };
-    this.onBlur = (id, data) => {
-      const {
-        onBlur
-      } = this.props;
+    _this.onBlur = function (id, data) {
+      var onBlur = _this.props.onBlur;
       if (onBlur) {
         onBlur(id, data);
       }
     };
-    this.onFocus = (id, data) => {
-      const {
-        onFocus
-      } = this.props;
+    _this.onFocus = function (id, data) {
+      var onFocus = _this.props.onFocus;
       if (onFocus) {
         onFocus(id, data);
       }
     };
-    this.onSubmit = event => {
+    _this.onSubmit = function (event) {
       event.preventDefault();
       if (event.target !== event.currentTarget) {
         return;
       }
       event.persist();
-      const {
-        omitExtraData,
-        extraErrors,
-        noValidate,
-        onSubmit
-      } = this.props;
-      let {
-        formData: newFormData
-      } = this.state;
-      const {
-        schema,
-        schemaUtils
-      } = this.state;
+      var _this$props2 = _this.props,
+        omitExtraData = _this$props2.omitExtraData,
+        extraErrors = _this$props2.extraErrors,
+        noValidate = _this$props2.noValidate,
+        onSubmit = _this$props2.onSubmit;
+      var newFormData = _this.state.formData;
+      var _this$state2 = _this.state,
+        schema = _this$state2.schema,
+        schemaUtils = _this$state2.schemaUtils;
       if (omitExtraData === true) {
-        const retrievedSchema = schemaUtils.retrieveSchema(schema, newFormData);
-        const pathSchema = schemaUtils.toPathSchema(retrievedSchema, "", newFormData);
-        const fieldNames = this.getFieldNames(pathSchema, newFormData);
-        newFormData = this.getUsedFormData(newFormData, fieldNames);
+        var retrievedSchema = schemaUtils.retrieveSchema(schema, newFormData);
+        var pathSchema = schemaUtils.toPathSchema(retrievedSchema, "", newFormData);
+        var fieldNames = _this.getFieldNames(pathSchema, newFormData);
+        newFormData = _this.getUsedFormData(newFormData, fieldNames);
       }
-      if (noValidate || this.validateForm()) {
+      if (noValidate || _this.validateForm()) {
         // There are no errors generated through schema validation.
         // Check for user provided errors and update state accordingly.
-        const errorSchema = extraErrors || {};
-        const errors = extraErrors ? schemaUtils.getValidator().toErrorList(extraErrors) : [];
-        this.setState({
+        var errorSchema = extraErrors || {};
+        var errors = extraErrors ? schemaUtils.getValidator().toErrorList(extraErrors) : [];
+        _this.setState({
           formData: newFormData,
-          errors,
-          errorSchema,
+          errors: errors,
+          errorSchema: errorSchema,
           schemaValidationErrors: [],
           schemaValidationErrorSchema: {}
-        }, () => {
+        }, function () {
           if (onSubmit) {
-            onSubmit({
-              ...this.state,
+            onSubmit(_extends({}, _this.state, {
               formData: newFormData,
               status: "submitted"
-            }, event);
+            }), event);
           }
         });
       }
@@ -3514,11 +3462,12 @@ class Form extends React.Component {
     if (!props.validator) {
       throw new Error("A validator is required for Form functionality to work");
     }
-    this.state = this.getStateFromProps(props, props.formData);
-    if (this.props.onChange && !utils.deepEquals(this.state.formData, this.props.formData)) {
-      this.props.onChange(this.state);
+    _this.state = _this.getStateFromProps(props, props.formData);
+    if (_this.props.onChange && !utils.deepEquals(_this.state.formData, _this.props.formData)) {
+      _this.props.onChange(_this.state);
     }
-    this.formElement = /*#__PURE__*/React__default["default"].createRef();
+    _this.formElement = /*#__PURE__*/React__default["default"].createRef();
+    return _this;
   }
   /** React lifecycle method that gets called before new props are provided, updates the state based on new props. It
    * will also call the`onChange` handler if the `formData` is modified to add missing default values as part of the
@@ -3526,8 +3475,9 @@ class Form extends React.Component {
    *
    * @param nextProps - The new set of props about to be applied to the `Form`
    */
-  UNSAFE_componentWillReceiveProps(nextProps) {
-    const nextState = this.getStateFromProps(nextProps, nextProps.formData);
+  var _proto = Form.prototype;
+  _proto.UNSAFE_componentWillReceiveProps = function UNSAFE_componentWillReceiveProps(nextProps) {
+    var nextState = this.getStateFromProps(nextProps, nextProps.formData);
     if (!utils.deepEquals(nextState.formData, nextProps.formData) && !utils.deepEquals(nextState.formData, this.state.formData) && nextProps.onChange) {
       nextProps.onChange(nextState);
     }
@@ -3540,22 +3490,22 @@ class Form extends React.Component {
    * @param props - The props passed to the `Form`
    * @param inputFormData - The new or current data for the `Form`
    * @returns - The new state for the `Form`
-   */
-  getStateFromProps(props, inputFormData) {
-    const state = this.state || {};
-    const schema = "schema" in props ? props.schema : this.props.schema;
-    const uiSchema = ("uiSchema" in props ? props.uiSchema : this.props.uiSchema) || {};
-    const edit = typeof inputFormData !== "undefined";
-    const liveValidate = "liveValidate" in props ? props.liveValidate : this.props.liveValidate;
-    const mustValidate = edit && !props.noValidate && liveValidate;
-    const rootSchema = schema;
-    let schemaUtils = state.schemaUtils;
+   */;
+  _proto.getStateFromProps = function getStateFromProps(props, inputFormData) {
+    var state = this.state || {};
+    var schema = "schema" in props ? props.schema : this.props.schema;
+    var uiSchema = ("uiSchema" in props ? props.uiSchema : this.props.uiSchema) || {};
+    var edit = typeof inputFormData !== "undefined";
+    var liveValidate = "liveValidate" in props ? props.liveValidate : this.props.liveValidate;
+    var mustValidate = edit && !props.noValidate && liveValidate;
+    var rootSchema = schema;
+    var schemaUtils = state.schemaUtils;
     if (!schemaUtils || schemaUtils.doesSchemaUtilsDiffer(props.validator, rootSchema)) {
       schemaUtils = utils.createSchemaUtils(props.validator, rootSchema);
     }
-    const formData = schemaUtils.getDefaultFormState(schema, inputFormData);
-    const retrievedSchema = schemaUtils.retrieveSchema(schema, formData);
-    const getCurrentErrors = () => {
+    var formData = schemaUtils.getDefaultFormState(schema, inputFormData);
+    var retrievedSchema = schemaUtils.retrieveSchema(schema, formData);
+    var getCurrentErrors = function getCurrentErrors() {
       if (props.noValidate) {
         return {
           errors: [],
@@ -3572,41 +3522,41 @@ class Form extends React.Component {
         errorSchema: state.errorSchema || {}
       };
     };
-    let errors;
-    let errorSchema;
-    let schemaValidationErrors = state.schemaValidationErrors;
-    let schemaValidationErrorSchema = state.schemaValidationErrorSchema;
+    var errors;
+    var errorSchema;
+    var schemaValidationErrors = state.schemaValidationErrors;
+    var schemaValidationErrorSchema = state.schemaValidationErrorSchema;
     if (mustValidate) {
-      const schemaValidation = this.validate(formData, schema, schemaUtils);
+      var schemaValidation = this.validate(formData, schema, schemaUtils);
       errors = schemaValidation.errors;
       errorSchema = schemaValidation.errorSchema;
       schemaValidationErrors = errors;
       schemaValidationErrorSchema = errorSchema;
     } else {
-      const currentErrors = getCurrentErrors();
+      var currentErrors = getCurrentErrors();
       errors = currentErrors.errors;
       errorSchema = currentErrors.errorSchema;
     }
     if (props.extraErrors) {
-      const merged = schemaUtils.mergeValidationData({
-        errorSchema,
-        errors
+      var merged = schemaUtils.mergeValidationData({
+        errorSchema: errorSchema,
+        errors: errors
       }, props.extraErrors);
       errorSchema = merged.errorSchema;
       errors = merged.errors;
     }
-    const idSchema = schemaUtils.toIdSchema(retrievedSchema, uiSchema["ui:rootFieldId"], formData, props.idPrefix, props.idSeparator);
-    const nextState = {
-      schemaUtils,
-      schema,
-      uiSchema,
-      idSchema,
-      formData,
-      edit,
-      errors,
-      errorSchema,
-      schemaValidationErrors,
-      schemaValidationErrorSchema
+    var idSchema = schemaUtils.toIdSchema(retrievedSchema, uiSchema["ui:rootFieldId"], formData, props.idPrefix, props.idSeparator);
+    var nextState = {
+      schemaUtils: schemaUtils,
+      schema: schema,
+      uiSchema: uiSchema,
+      idSchema: idSchema,
+      formData: formData,
+      edit: edit,
+      errors: errors,
+      errorSchema: errorSchema,
+      schemaValidationErrors: schemaValidationErrors,
+      schemaValidationErrorSchema: schemaValidationErrorSchema
     };
     return nextState;
   }
@@ -3615,8 +3565,8 @@ class Form extends React.Component {
    * @param nextProps - The next version of the props
    * @param nextState - The next version of the state
    * @returns - True if the component should be updated, false otherwise
-   */
-  shouldComponentUpdate(nextProps, nextState) {
+   */;
+  _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
     return utils.shouldRender(this, nextProps, nextState);
   }
   /** Validates the `formData` against the `schema` using the `altSchemaUtils` (if provided otherwise it uses the
@@ -3625,32 +3575,28 @@ class Form extends React.Component {
    * @param formData - The new form data to validate
    * @param schema - The schema used to validate against
    * @param altSchemaUtils - The alternate schemaUtils to use for validation
-   */
-  validate(formData, schema, altSchemaUtils) {
+   */;
+  _proto.validate = function validate(formData, schema, altSchemaUtils) {
     if (schema === void 0) {
       schema = this.props.schema;
     }
-    const schemaUtils = altSchemaUtils ? altSchemaUtils : this.state.schemaUtils;
-    const {
-      customValidate,
-      transformErrors
-    } = this.props;
-    const resolvedSchema = schemaUtils.retrieveSchema(schema, formData);
+    var schemaUtils = altSchemaUtils ? altSchemaUtils : this.state.schemaUtils;
+    var _this$props3 = this.props,
+      customValidate = _this$props3.customValidate,
+      transformErrors = _this$props3.transformErrors;
+    var resolvedSchema = schemaUtils.retrieveSchema(schema, formData);
     return schemaUtils.getValidator().validateFormData(formData, resolvedSchema, customValidate, transformErrors);
   }
-  /** Renders any errors contained in the `state` in using the `ErrorList`, if not disabled by `showErrorList`. */
-  renderErrors(registry) {
-    const {
-      errors,
-      errorSchema,
-      schema,
-      uiSchema
-    } = this.state;
-    const {
-      formContext
-    } = this.props;
-    const options = utils.getUiOptions(uiSchema);
-    const ErrorListTemplate = utils.getTemplate("ErrorListTemplate", registry, options);
+  /** Renders any errors contained in the `state` in using the `ErrorList`, if not disabled by `showErrorList`. */;
+  _proto.renderErrors = function renderErrors(registry) {
+    var _this$state3 = this.state,
+      errors = _this$state3.errors,
+      errorSchema = _this$state3.errorSchema,
+      schema = _this$state3.schema,
+      uiSchema = _this$state3.uiSchema;
+    var formContext = this.props.formContext;
+    var options = utils.getUiOptions(uiSchema);
+    var ErrorListTemplate = utils.getTemplate("ErrorListTemplate", registry, options);
     if (errors && errors.length) {
       return /*#__PURE__*/React__default["default"].createElement(ErrorListTemplate, {
         errors: errors,
@@ -3666,44 +3612,29 @@ class Form extends React.Component {
    *
    * @param formData - The data for the `Form`
    * @param fields - The fields to keep while filtering
-   */
-
+   */;
   /** Returns the registry for the form */
-  getRegistry() {
+  _proto.getRegistry = function getRegistry() {
     var _this$props$templates;
-    const {
-      schemaUtils
-    } = this.state;
-    const {
-      fields,
-      templates,
-      widgets,
-      formContext
-    } = getDefaultRegistry();
+    var schemaUtils = this.state.schemaUtils;
+    var _getDefaultRegistry = getDefaultRegistry(),
+      fields = _getDefaultRegistry.fields,
+      templates = _getDefaultRegistry.templates,
+      widgets = _getDefaultRegistry.widgets,
+      formContext = _getDefaultRegistry.formContext;
     return {
-      fields: {
-        ...fields,
-        ...this.props.fields
-      },
-      templates: {
-        ...templates,
-        ...this.props.templates,
-        ButtonTemplates: {
-          ...templates.ButtonTemplates,
-          ...((_this$props$templates = this.props.templates) === null || _this$props$templates === void 0 ? void 0 : _this$props$templates.ButtonTemplates)
-        }
-      },
-      widgets: {
-        ...widgets,
-        ...this.props.widgets
-      },
+      fields: _extends({}, fields, this.props.fields),
+      templates: _extends({}, templates, this.props.templates, {
+        ButtonTemplates: _extends({}, templates.ButtonTemplates, (_this$props$templates = this.props.templates) === null || _this$props$templates === void 0 ? void 0 : _this$props$templates.ButtonTemplates)
+      }),
+      widgets: _extends({}, widgets, this.props.widgets),
       rootSchema: this.props.schema,
       formContext: this.props.formContext || formContext,
-      schemaUtils
+      schemaUtils: schemaUtils
     };
   }
-  /** Provides a function that can be used to programmatically submit the `Form` */
-  submit() {
+  /** Provides a function that can be used to programmatically submit the `Form` */;
+  _proto.submit = function submit() {
     if (this.formElement.current) {
       this.formElement.current.dispatchEvent(new CustomEvent("submit", {
         cancelable: true
@@ -3715,35 +3646,30 @@ class Form extends React.Component {
    * same way as would happen on form submission.
    *
    * @returns - True if the form is valid, false otherwise.
-   */
-  validateForm() {
-    const {
-      extraErrors,
-      onError
-    } = this.props;
-    const {
-      formData
-    } = this.state;
-    const {
-      schemaUtils
-    } = this.state;
-    const schemaValidation = this.validate(formData);
-    let errors = schemaValidation.errors;
-    let errorSchema = schemaValidation.errorSchema;
-    const schemaValidationErrors = errors;
-    const schemaValidationErrorSchema = errorSchema;
+   */;
+  _proto.validateForm = function validateForm() {
+    var _this$props4 = this.props,
+      extraErrors = _this$props4.extraErrors,
+      onError = _this$props4.onError;
+    var formData = this.state.formData;
+    var schemaUtils = this.state.schemaUtils;
+    var schemaValidation = this.validate(formData);
+    var errors = schemaValidation.errors;
+    var errorSchema = schemaValidation.errorSchema;
+    var schemaValidationErrors = errors;
+    var schemaValidationErrorSchema = errorSchema;
     if (errors.length > 0) {
       if (extraErrors) {
-        const merged = schemaUtils.mergeValidationData(schemaValidation, extraErrors);
+        var merged = schemaUtils.mergeValidationData(schemaValidation, extraErrors);
         errorSchema = merged.errorSchema;
         errors = merged.errors;
       }
       this.setState({
-        errors,
-        errorSchema,
-        schemaValidationErrors,
-        schemaValidationErrorSchema
-      }, () => {
+        errors: errors,
+        errorSchema: errorSchema,
+        schemaValidationErrors: schemaValidationErrors,
+        schemaValidationErrorSchema: schemaValidationErrorSchema
+      }, function () {
         if (onError) {
           onError(errors);
         } else {
@@ -3756,48 +3682,47 @@ class Form extends React.Component {
   }
   /** Renders the `Form` fields inside the <form> | `tagName` or `_internalFormWrapper`, rendering any errors if
    * needed along with the submit button or any children of the form.
-   */
-  render() {
-    const {
-      children,
-      id,
-      idPrefix,
-      idSeparator,
-      className = "",
-      tagName,
-      name,
-      method,
-      target,
-      action,
-      autoComplete,
-      enctype,
-      acceptcharset,
-      noHtml5Validate = false,
-      disabled = false,
-      readonly = false,
-      formContext,
-      showErrorList = "top",
-      _internalFormWrapper
-    } = this.props;
-    const {
-      schema,
-      uiSchema,
-      formData,
-      errorSchema,
-      idSchema
-    } = this.state;
-    const registry = this.getRegistry();
-    const {
-      SchemaField: _SchemaField
-    } = registry.fields;
-    const {
-      SubmitButton
-    } = registry.templates.ButtonTemplates;
+   */;
+  _proto.render = function render() {
+    var _this$props5 = this.props,
+      children = _this$props5.children,
+      id = _this$props5.id,
+      idPrefix = _this$props5.idPrefix,
+      idSeparator = _this$props5.idSeparator,
+      _this$props5$classNam = _this$props5.className,
+      className = _this$props5$classNam === void 0 ? "" : _this$props5$classNam,
+      tagName = _this$props5.tagName,
+      name = _this$props5.name,
+      method = _this$props5.method,
+      target = _this$props5.target,
+      action = _this$props5.action,
+      autoComplete = _this$props5.autoComplete,
+      enctype = _this$props5.enctype,
+      acceptcharset = _this$props5.acceptcharset,
+      _this$props5$noHtml5V = _this$props5.noHtml5Validate,
+      noHtml5Validate = _this$props5$noHtml5V === void 0 ? false : _this$props5$noHtml5V,
+      _this$props5$disabled = _this$props5.disabled,
+      disabled = _this$props5$disabled === void 0 ? false : _this$props5$disabled,
+      _this$props5$readonly = _this$props5.readonly,
+      readonly = _this$props5$readonly === void 0 ? false : _this$props5$readonly,
+      formContext = _this$props5.formContext,
+      _this$props5$showErro = _this$props5.showErrorList,
+      showErrorList = _this$props5$showErro === void 0 ? "top" : _this$props5$showErro,
+      _internalFormWrapper = _this$props5._internalFormWrapper;
+    var _this$state4 = this.state,
+      schema = _this$state4.schema,
+      uiSchema = _this$state4.uiSchema,
+      formData = _this$state4.formData,
+      errorSchema = _this$state4.errorSchema,
+      idSchema = _this$state4.idSchema;
+    var registry = this.getRegistry();
+    var _SchemaField = registry.fields.SchemaField;
+    var SubmitButton = registry.templates.ButtonTemplates.SubmitButton;
     // The `semantic-ui` and `material-ui` themes have `_internalFormWrapper`s that take an `as` prop that is the
     // PropTypes.elementType to use for the inner tag, so we'll need to pass `tagName` along if it is provided.
     // NOTE, the `as` prop is native to `semantic-ui` and is emulated in the `material-ui` theme
-    const as = _internalFormWrapper ? tagName : undefined;
-    const FormTag = _internalFormWrapper || tagName || "form";
+    var as = _internalFormWrapper ? tagName : undefined;
+    var FormTag = _internalFormWrapper || tagName || "form";
     return /*#__PURE__*/React__default["default"].createElement(FormTag, {
       className: className ? className : "rjsf",
       id: id,
@@ -3831,43 +3756,30 @@ class Form extends React.Component {
     }), children ? children : /*#__PURE__*/React__default["default"].createElement(SubmitButton, {
       uiSchema: uiSchema
     }), showErrorList === "bottom" && this.renderErrors(registry));
-  }
-}
+  };
+  return Form;
+}(React.Component);
 
+var _excluded = ["fields", "widgets", "templates"];
 /** A Higher-Order component that creates a wrapper around a `Form` with the overrides from the `WithThemeProps` */
 function withTheme(themeProps) {
-  return /*#__PURE__*/React.forwardRef((_ref, ref) => {
+  return /*#__PURE__*/React.forwardRef(function (_ref, ref) {
     var _themeProps$templates, _templates;
-    let {
-      fields,
-      widgets,
-      templates,
-      ...directProps
-    } = _ref;
-    fields = {
-      ...themeProps.fields,
-      ...fields
-    };
-    widgets = {
-      ...themeProps.widgets,
-      ...widgets
-    };
-    templates = {
-      ...themeProps.templates,
-      ...templates,
-      ButtonTemplates: {
-        ...(themeProps === null || themeProps === void 0 ? void 0 : (_themeProps$templates = themeProps.templates) === null || _themeProps$templates === void 0 ? void 0 : _themeProps$templates.ButtonTemplates),
-        ...((_templates = templates) === null || _templates === void 0 ? void 0 : _templates.ButtonTemplates)
-      }
-    };
-    return /*#__PURE__*/React__default["default"].createElement(Form, {
-      ...themeProps,
-      ...directProps,
+    var fields = _ref.fields,
+      widgets = _ref.widgets,
+      templates = _ref.templates,
+      directProps = _objectWithoutPropertiesLoose(_ref, _excluded);
+    fields = _extends({}, themeProps.fields, fields);
+    widgets = _extends({}, themeProps.widgets, widgets);
+    templates = _extends({}, themeProps.templates, templates, {
+      ButtonTemplates: _extends({}, themeProps === null || themeProps === void 0 ? void 0 : (_themeProps$templates = themeProps.templates) === null || _themeProps$templates === void 0 ? void 0 : _themeProps$templates.ButtonTemplates, (_templates = templates) === null || _templates === void 0 ? void 0 : _templates.ButtonTemplates)
+    });
+    return /*#__PURE__*/React__default["default"].createElement(Form, _extends({}, themeProps, directProps, {
       fields: fields,
       widgets: widgets,
       templates: templates,
       ref: ref
-    });
+    }));
   });
 }