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

package/dist/core.umd.development.js

@@ -16,6 +16,96 @@
   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();
@@ -26,10 +116,10 @@
    * @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
       };
     });
   }
@@ -40,96 +130,90 @@
    */
   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) {
@@ -137,28 +221,31 @@
               }
             }
           }
-          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) {
@@ -168,58 +255,54 @@
               }
             }
           }
-          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
@@ -227,16 +310,16 @@
      * @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]
@@ -248,20 +331,15 @@
     }
     /** 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.
@@ -276,15 +354,13 @@
      *
      * @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
@@ -298,23 +374,19 @@
     }
     /** 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,
@@ -338,116 +410,115 @@
       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,
@@ -471,47 +542,48 @@
       });
     }
     /** 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,
@@ -527,33 +599,35 @@
       });
     }
     /** 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,
@@ -576,150 +650,150 @@
       });
     }
     /** 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,
@@ -744,75 +818,83 @@
           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"
@@ -822,17 +904,16 @@
         }];
       } 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,
@@ -851,41 +932,42 @@
     });
   }
 
+  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);
                 }
@@ -895,18 +977,18 @@
         }
         // 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`
@@ -914,17 +996,15 @@
      * @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;
         }
@@ -938,12 +1018,10 @@
      * @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;
       }
@@ -956,56 +1034,51 @@
      * 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
@@ -1013,32 +1086,34 @@
           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,
@@ -1056,19 +1131,20 @@
         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
@@ -1087,51 +1163,48 @@
    *    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
@@ -1139,25 +1212,28 @@
    *
    * @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
@@ -1168,117 +1244,95 @@
             // 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
@@ -1288,13 +1342,12 @@
      * @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";
@@ -1317,46 +1370,44 @@
      * 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", {
@@ -1366,20 +1417,20 @@
           }
         }, "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),
@@ -1388,50 +1439,51 @@
               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
@@ -1444,30 +1496,30 @@
    * @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
       });
     };
@@ -1479,63 +1531,58 @@
    * @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,
@@ -1547,19 +1594,19 @@
       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");
     }
@@ -1572,7 +1619,7 @@
     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,
@@ -1580,7 +1627,7 @@
       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,
@@ -1588,9 +1635,9 @@
       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,
@@ -1601,29 +1648,27 @@
       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,
@@ -1637,7 +1682,9 @@
       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,
@@ -1656,7 +1703,9 @@
       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,
@@ -1666,63 +1715,65 @@
   /** 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,
@@ -1748,11 +1799,9 @@
    * @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);
       }
@@ -1765,13 +1814,13 @@
       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
     };
   }
 
@@ -1781,22 +1830,19 @@
    * @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,
@@ -1811,27 +1857,24 @@
    * @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,
@@ -1867,35 +1910,30 @@
     }))));
   }
 
+  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
@@ -1914,15 +1952,12 @@
       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,
@@ -1937,23 +1972,20 @@
    * @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,
@@ -1964,6 +1996,7 @@
     });
   }
 
+  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.
@@ -1971,161 +2004,136 @@
    * @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",
@@ -2138,11 +2146,11 @@
 
   function buttonTemplates() {
     return {
-      SubmitButton,
-      AddButton,
-      MoveDownButton,
-      MoveUpButton,
-      RemoveButton
+      SubmitButton: SubmitButton,
+      AddButton: AddButton,
+      MoveDownButton: MoveDownButton,
+      MoveUpButton: MoveUpButton,
+      RemoveButton: RemoveButton
     };
   }
 
@@ -2151,10 +2159,8 @@
    * @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;
     }
@@ -2176,9 +2182,7 @@
    * @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", {
@@ -2187,7 +2191,7 @@
       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"
@@ -2195,17 +2199,15 @@
     })));
   }
 
-  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;
     }
@@ -2223,29 +2225,25 @@
    * @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
@@ -2257,18 +2255,19 @@
    * @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
@@ -2281,14 +2280,12 @@
    * @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,
@@ -2308,45 +2305,41 @@
    * @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,
@@ -2354,17 +2347,15 @@
     }));
   }
 
-  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", {
@@ -2378,11 +2369,9 @@
    * @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)));
@@ -2394,26 +2383,22 @@
    * @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
@@ -2430,12 +2415,14 @@
     }, /*#__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"
@@ -2454,27 +2441,27 @@
 
   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)
@@ -2483,21 +2470,21 @@
     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
@@ -2528,23 +2515,19 @@
     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"
@@ -2559,7 +2542,9 @@
       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,
@@ -2570,50 +2555,50 @@
    * @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;
@@ -2623,19 +2608,21 @@
     }, [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
@@ -2646,23 +2633,20 @@
     }, "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.
@@ -2671,31 +2655,36 @@
    * @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,
@@ -2717,14 +2706,18 @@
   }
 
   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.
@@ -2732,31 +2725,28 @@
    * @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) {
@@ -2765,9 +2755,9 @@
           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,
@@ -2776,10 +2766,10 @@
       }), /*#__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));
     }));
   }
@@ -2790,18 +2780,16 @@
    * @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
@@ -2810,18 +2798,18 @@
    * @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
@@ -2830,19 +2818,19 @@
    * @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`.
@@ -2850,47 +2838,42 @@
    * @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
           });
         }
       };
@@ -2901,31 +2884,28 @@
     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,
@@ -2938,25 +2918,30 @@
    *  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 {
@@ -2985,10 +2970,8 @@
    * @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,
@@ -3002,15 +2985,12 @@
    * @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.
@@ -3019,40 +2999,43 @@
    * @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,
@@ -3065,10 +3048,10 @@
       }), /*#__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));
     }));
   }
@@ -3079,27 +3062,24 @@
    * @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;
   }
@@ -3109,36 +3089,34 @@
    * @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", {
@@ -3153,14 +3131,12 @@
       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,
@@ -3174,41 +3150,29 @@
    * @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", {
@@ -3237,14 +3201,10 @@
    * @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`.
@@ -3252,15 +3212,12 @@
    * @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`.
@@ -3268,37 +3225,34 @@
    * @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
     };
   }
 
@@ -3317,7 +3271,8 @@
   }
 
   /** 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
      */
@@ -3328,32 +3283,37 @@
      *
      * @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]);
@@ -3361,8 +3321,8 @@
                 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)) {
@@ -3375,128 +3335,116 @@
         };
         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);
             }
           });
         }
@@ -3504,11 +3452,12 @@
       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
@@ -3516,8 +3465,9 @@
      *
      * @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);
       }
@@ -3530,22 +3480,22 @@
      * @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: [],
@@ -3562,41 +3512,41 @@
           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;
     }
@@ -3605,8 +3555,8 @@
      * @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
@@ -3615,32 +3565,28 @@
      * @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,
@@ -3656,44 +3602,29 @@
      *
      * @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
@@ -3705,35 +3636,30 @@
      * 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 {
@@ -3746,48 +3672,47 @@
     }
     /** 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,
@@ -3821,43 +3746,30 @@
       }), 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
-      });
+      }));
     });
   }