@thecb/components 3.5.2 → 3.5.3

package/dist/index.cjs.js

@@ -215,63 +215,6 @@ function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it;
-
-  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it) o = it;
-      var i = 0;
-
-      var F = function () {};
-
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function (e) {
-          throw e;
-        },
-        f: F
-      };
-    }
-
-    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 normalCompletion = true,
-      didErr = false,
-      err;
-  return {
-    s: function () {
-      it = o[Symbol.iterator]();
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
-      }
-    }
-  };
-}
-
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -19128,7 +19071,7 @@ var Loading = function Loading() {
   return /*#__PURE__*/React__default.createElement(Box, {
     key: "spinner-container"
   }, /*#__PURE__*/React__default.createElement(Cover, {
-    minHeight: "100%",
+    minHeight: "100vh",
     singleChild: true
   }, /*#__PURE__*/React__default.createElement(Center, {
     intrinsic: true
@@ -30572,401 +30515,378 @@ var ToggleSwitch = function ToggleSwitch(_ref6) {
 
 var ToggleSwitch$1 = themeComponent(ToggleSwitch, "ToggleSwitch", fallbackValues$o);
 
-var validatorToPredicate = function validatorToPredicate(validatorFn, emptyCase) {
-  return function (value) {
-    for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      rest[_key - 1] = arguments[_key];
-    }
+const validatorToPredicate = (validatorFn, emptyCase) => (
+  value,
+  ...rest
+) => (value === "" ? emptyCase : validatorFn(value, ...rest));
 
-    return value === "" ? emptyCase : validatorFn.apply(void 0, [value].concat(rest));
-  };
-};
 /* eslint-disable no-unused-vars */
 
-
-var createValidator = function createValidator(type, error) {
-  var validator = function validator() {
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
-
-    return {
-      type: type,
-      args: args,
-      error: error
-    };
-  };
-
+const createValidator = (type, error) => {
+  let validator = (...args) => ({ type, args, error });
   validator.error = error;
   return validator;
 };
 
-var validatorFns = {};
-var REQUIRED = "validator/REQUIRED";
-var REQUIRED_ERROR = "error/REQUIRED";
-var required = createValidator(REQUIRED, REQUIRED_ERROR);
+let validatorFns = {};
 
-validatorFns[REQUIRED] = function (value, args, form) {
-  return value !== "";
-};
+const REQUIRED = "validator/REQUIRED";
+const REQUIRED_ERROR = "error/REQUIRED";
+const required = createValidator(REQUIRED, REQUIRED_ERROR);
+validatorFns[REQUIRED] = (value, args, form) => value !== "";
 
-var ONLY_INTEGERS = "validator/ONLY_INTEGERS";
-var ONLY_INTEGERS_ERROR = "error/ONLY_INTEGERS";
-var onlyIntegers = createValidator(ONLY_INTEGERS, ONLY_INTEGERS_ERROR);
+const ONLY_INTEGERS = "validator/ONLY_INTEGERS";
+const ONLY_INTEGERS_ERROR = "error/ONLY_INTEGERS";
+const onlyIntegers = createValidator(ONLY_INTEGERS, ONLY_INTEGERS_ERROR);
+validatorFns[ONLY_INTEGERS] = (value, args, form) => /^(-?\d+)?$/.test(value);
 
-validatorFns[ONLY_INTEGERS] = function (value, args, form) {
-  return /^(-?\d+)?$/.test(value);
-};
+const ONLY_NATURALS = "validator/ONLY_NATURALS";
+const ONLY_NATURALS_ERROR = "error/ONLY_NATURALS";
+const onlyNaturals = createValidator(ONLY_NATURALS, ONLY_NATURALS_ERROR);
+validatorFns[ONLY_NATURALS] = (value, args, form) => /^(\d+)?$/.test(value);
 
-var ONLY_NATURALS = "validator/ONLY_NATURALS";
-var ONLY_NATURALS_ERROR = "error/ONLY_NATURALS";
-var onlyNaturals = createValidator(ONLY_NATURALS, ONLY_NATURALS_ERROR);
-
-validatorFns[ONLY_NATURALS] = function (value, args, form) {
-  return /^(\d+)?$/.test(value);
-};
-
-var NUMBER_LESS_THAN = "validator/NUMBER_LESS_THAN";
-var NUMBER_LESS_THAN_ERROR = "error/NUMBER_LESS_THAN";
-var numberLessThan = createValidator(NUMBER_LESS_THAN, NUMBER_LESS_THAN_ERROR);
-
-validatorFns[NUMBER_LESS_THAN] = function (value, args, form) {
+const NUMBER_LESS_THAN = "validator/NUMBER_LESS_THAN";
+const NUMBER_LESS_THAN_ERROR = "error/NUMBER_LESS_THAN";
+const numberLessThan = createValidator(
+  NUMBER_LESS_THAN,
+  NUMBER_LESS_THAN_ERROR
+);
+validatorFns[NUMBER_LESS_THAN] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return Number(value) < args[0];
 };
 
-var NUMBER_LESS_THAN_OR_EQUAL_TO = "validator/NUMBER_LESS_THAN_OR_EQUAL_TO";
-var NUMBER_LESS_THAN_OR_EQUAL_TO_ERROR = "error/NUMBER_LESS_THAN_OR_EQUAL_TO";
-var numberLessThanOrEqualTo = createValidator(NUMBER_LESS_THAN_OR_EQUAL_TO, NUMBER_LESS_THAN_OR_EQUAL_TO_ERROR);
-
-validatorFns[NUMBER_LESS_THAN_OR_EQUAL_TO] = function (value, args, form) {
+const NUMBER_LESS_THAN_OR_EQUAL_TO =
+  "validator/NUMBER_LESS_THAN_OR_EQUAL_TO";
+const NUMBER_LESS_THAN_OR_EQUAL_TO_ERROR =
+  "error/NUMBER_LESS_THAN_OR_EQUAL_TO";
+const numberLessThanOrEqualTo = createValidator(
+  NUMBER_LESS_THAN_OR_EQUAL_TO,
+  NUMBER_LESS_THAN_OR_EQUAL_TO_ERROR
+);
+validatorFns[NUMBER_LESS_THAN_OR_EQUAL_TO] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return Number(value) <= args[0];
 };
 
-var NUMBER_GREATER_THAN = "validator/NUMBER_GREATER_THAN";
-var NUMBER_GREATER_THAN_ERROR = "error/NUMBER_GREATER_THAN";
-var numberGreaterThan = createValidator(NUMBER_GREATER_THAN, NUMBER_GREATER_THAN_ERROR);
-
-validatorFns[NUMBER_GREATER_THAN] = function (value, args, form) {
+const NUMBER_GREATER_THAN = "validator/NUMBER_GREATER_THAN";
+const NUMBER_GREATER_THAN_ERROR = "error/NUMBER_GREATER_THAN";
+const numberGreaterThan = createValidator(
+  NUMBER_GREATER_THAN,
+  NUMBER_GREATER_THAN_ERROR
+);
+validatorFns[NUMBER_GREATER_THAN] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return Number(value) > args[0];
 };
 
-var NUMBER_GREATER_THAN_OR_EQUAL_TO = "validator/NUMBER_GREATER_THAN_OR_EQUAL_TO";
-var NUMBER_GREATER_THAN_OR_EQUAL_TO_ERROR = "error/NUMBER_GREATER_THAN_OR_EQUAL_TO";
-var numberGreaterThanOrEqualTo = createValidator(NUMBER_GREATER_THAN_OR_EQUAL_TO, NUMBER_GREATER_THAN_OR_EQUAL_TO_ERROR);
-
-validatorFns[NUMBER_GREATER_THAN_OR_EQUAL_TO] = function (value, args, form) {
+const NUMBER_GREATER_THAN_OR_EQUAL_TO =
+  "validator/NUMBER_GREATER_THAN_OR_EQUAL_TO";
+const NUMBER_GREATER_THAN_OR_EQUAL_TO_ERROR =
+  "error/NUMBER_GREATER_THAN_OR_EQUAL_TO";
+const numberGreaterThanOrEqualTo = createValidator(
+  NUMBER_GREATER_THAN_OR_EQUAL_TO,
+  NUMBER_GREATER_THAN_OR_EQUAL_TO_ERROR
+);
+validatorFns[NUMBER_GREATER_THAN_OR_EQUAL_TO] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return Number(value) >= args[0];
 };
 
-var MATCHES_FIELD = "validator/MATCHES_FIELD";
-var MATCHES_FIELD_ERROR$1 = "error/MATCHES_FIELD";
-var matchesField = createValidator(MATCHES_FIELD, MATCHES_FIELD_ERROR$1);
-
-validatorFns[MATCHES_FIELD] = function (value, args, form) {
+const MATCHES_FIELD = "validator/MATCHES_FIELD";
+const MATCHES_FIELD_ERROR$1 = "error/MATCHES_FIELD";
+const matchesField = createValidator(MATCHES_FIELD, MATCHES_FIELD_ERROR$1);
+validatorFns[MATCHES_FIELD] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   if (form[args[0]] === undefined) {
-    throw new Error("".concat(args[0], " was passed to matchesField, but that field does not exist in the form"));
+    throw new Error(
+      `${args[0]} was passed to matchesField, but that field does not exist in the form`
+    );
   }
-
   return value === form[args[0]].rawValue;
 };
 
-var validateWhenErrorMessage = function validateWhenErrorMessage(type) {
-  return "".concat(type, " was passed to validateWhen, but that validator type does not exist.\n  Please check that you are only calling validator creator functions exported from\n  redux-freeform in your form config and that you didn't forget to\n  invoke the validator creator (you cannot pass the functions themselves to\n  createFormState). Also make sure you aren't passing validateWhen() to validateWhen\n  as the primary validator.");
-};
-
-var VALIDATE_WHEN = "validator/VALIDATE_WHEN";
-var VALIDATE_WHEN_ERROR = "error/VALIDATE_WHEN";
-
-var validateWhen = function validateWhen(dependentValidator, primaryValidator, optionalFieldName) {
-  return {
-    type: VALIDATE_WHEN,
-    args: [dependentValidator, primaryValidator, optionalFieldName],
-    error: dependentValidator.error
-  };
-};
-
+const validateWhenErrorMessage = type =>
+  `${type} was passed to validateWhen, but that validator type does not exist.
+  Please check that you are only calling validator creator functions exported from
+  redux-freeform in your form config and that you didn't forget to
+  invoke the validator creator (you cannot pass the functions themselves to
+  createFormState). Also make sure you aren't passing validateWhen() to validateWhen
+  as the primary validator.`;
+
+const VALIDATE_WHEN = "validator/VALIDATE_WHEN";
+const VALIDATE_WHEN_ERROR = "error/VALIDATE_WHEN";
+const validateWhen = (
+  dependentValidator,
+  primaryValidator,
+  optionalFieldName
+) => ({
+  type: VALIDATE_WHEN,
+  args: [dependentValidator, primaryValidator, optionalFieldName],
+  error: dependentValidator.error
+});
 validateWhen.error = VALIDATE_WHEN_ERROR;
+validatorFns[VALIDATE_WHEN] = (value, args, form) => {
+  const [dependentValidator, primaryValidator, optionalFieldName] = args;
+  const dependsOnOtherField = typeof optionalFieldName === "string";
 
-validatorFns[VALIDATE_WHEN] = function (value, args, form) {
-  var _args = _slicedToArray(args, 3),
-      dependentValidator = _args[0],
-      primaryValidator = _args[1],
-      optionalFieldName = _args[2];
-
-  var dependsOnOtherField = typeof optionalFieldName === "string";
-
-  if (primaryValidator.type === undefined || typeof validatorFns[primaryValidator.type] !== "function") {
+  if (
+    primaryValidator.type === undefined ||
+    typeof validatorFns[primaryValidator.type] !== "function"
+  ) {
     throw new Error(validateWhenErrorMessage(primaryValidator.type));
   }
-
   if (dependsOnOtherField && form[optionalFieldName] === undefined) {
-    throw new Error("".concat(args[2], " was passed to matchesField, but that field does not exist in the form"));
+    throw new Error(
+      `${args[2]} was passed to matchesField, but that field does not exist in the form`
+    );
   }
 
-  var primaryPredicate = validatorToPredicate(validatorFns[primaryValidator.type], false);
-  var primaryValue = dependsOnOtherField ? form[optionalFieldName].rawValue : value;
-  var primaryPredicatePassed = primaryPredicate(primaryValue, primaryValidator.args, form);
-  return primaryPredicatePassed ? validatorFns[dependentValidator.type](value, dependentValidator.args, form) : true;
-};
-
-var validateSumErrorMessage = function validateSumErrorMessage(type) {
-  return "".concat(type, " was passed to validateSum, but that validator type does not exist.\n  Please check that you are only calling validator creator functions exported from\n  redux-freeform in your form config and that you didn't forget to\n  invoke the validator creator (you cannot pass the functions themselves to\n  createFormState).");
-};
-
-var VALIDATE_SUM = "validator/VALIDATE_SUM";
-var VALIDATE_SUM_ERROR = "error/VALIDATE_SUM";
-
-var validateSum = function validateSum(validator, fieldNamesArray) {
-  return {
-    type: VALIDATE_SUM,
-    args: [validator, fieldNamesArray],
-    error: validator.error
-  };
-};
+  const primaryPredicate = validatorToPredicate(
+    validatorFns[primaryValidator.type],
+    false
+  );
+  const primaryValue = dependsOnOtherField
+    ? form[optionalFieldName].rawValue
+    : value;
+  const primaryPredicatePassed = primaryPredicate(
+    primaryValue,
+    primaryValidator.args,
+    form
+  );
 
+  return primaryPredicatePassed
+    ? validatorFns[dependentValidator.type](
+        value,
+        dependentValidator.args,
+        form
+      )
+    : true;
+};
+
+const validateSumErrorMessage = type =>
+  `${type} was passed to validateSum, but that validator type does not exist.
+  Please check that you are only calling validator creator functions exported from
+  redux-freeform in your form config and that you didn't forget to
+  invoke the validator creator (you cannot pass the functions themselves to
+  createFormState).`;
+const VALIDATE_SUM = "validator/VALIDATE_SUM";
+const VALIDATE_SUM_ERROR = "error/VALIDATE_SUM";
+const validateSum = (validator, fieldNamesArray) => ({
+  type: VALIDATE_SUM,
+  args: [validator, fieldNamesArray],
+  error: validator.error
+});
 validateSum.error = VALIDATE_SUM_ERROR;
+validatorFns[VALIDATE_SUM] = (value, args, form) => {
+  const [validator, fieldNamesArray] = args;
 
-validatorFns[VALIDATE_SUM] = function (value, args, form) {
-  var _args2 = _slicedToArray(args, 2),
-      validator = _args2[0],
-      fieldNamesArray = _args2[1];
-
-  if (validator.type === undefined || typeof validatorFns[validator.type] !== "function") {
+  if (
+    validator.type === undefined ||
+    typeof validatorFns[validator.type] !== "function"
+  ) {
     throw new Error(validateSumErrorMessage(validator.type));
   }
 
-  var _iterator = _createForOfIteratorHelper(fieldNamesArray),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var fieldName = _step.value;
-
-      if (form[fieldName] === undefined) {
-        throw new Error("".concat(fieldName, " was passed to matchesField, but that field does not exist in the form"));
-      }
+  for (const fieldName of fieldNamesArray) {
+    if (form[fieldName] === undefined) {
+      throw new Error(
+        `${fieldName} was passed to matchesField, but that field does not exist in the form`
+      );
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
 
-  var sum = fieldNamesArray.reduce(function (acc, curr) {
-    return acc + Number(form[curr].rawValue);
-  }, Number(value));
+  const sum = fieldNamesArray.reduce(
+    (acc, curr) => acc + Number(form[curr].rawValue),
+    Number(value)
+  );
+
   return validatorFns[validator.type](sum, validator.args, form);
 };
 
-var HAS_LENGTH = "validator/HAS_LENGTH";
-var HAS_LENGTH_ERROR = "error/HAS_LENGTH";
-var hasLength = createValidator(HAS_LENGTH, HAS_LENGTH_ERROR);
-
-validatorFns[HAS_LENGTH] = function (value, args, form) {
+const HAS_LENGTH = "validator/HAS_LENGTH";
+const HAS_LENGTH_ERROR = "error/HAS_LENGTH";
+const hasLength = createValidator(HAS_LENGTH, HAS_LENGTH_ERROR);
+validatorFns[HAS_LENGTH] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
-  var min = args[0];
-  var max = args[1];
-
+  const min = args[0];
+  const max = args[1];
   if (max == undefined || min == undefined) {
-    throw new Error("Max and min need to be defined for hasLength, both or one of them is undefined");
+    throw new Error(
+      "Max and min need to be defined for hasLength, both or one of them is undefined"
+    );
   }
-
   if (max < min) {
-    throw new Error("hasLength validator was passed a min greater than the max");
+    throw new Error(
+      "hasLength validator was passed a min greater than the max"
+    );
   }
-
-  var valueLength = value.length;
+  const valueLength = value.length;
   return max >= valueLength && valueLength >= min;
 };
 
-var MATCHES_REGEX = "validator/MATCHES_REGEX";
-var MATCHES_REGEX_ERROR = "error/MATCHES_REGEX";
-var matchesRegex = createValidator(MATCHES_REGEX, MATCHES_REGEX_ERROR);
-
-validatorFns[MATCHES_REGEX] = function (value, args, form) {
+const MATCHES_REGEX = "validator/MATCHES_REGEX";
+const MATCHES_REGEX_ERROR = "error/MATCHES_REGEX";
+const matchesRegex = createValidator(MATCHES_REGEX, MATCHES_REGEX_ERROR);
+validatorFns[MATCHES_REGEX] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return new RegExp(args[0]).test(value); // new RexExp never throws an error, no matter the input
-}; // based on http://www.brainjar.com/js/validation/
-
-
-var IS_ROUTING_NUMBER = "validator/IS_ROUTING_NUMBER";
-var IS_ROUTING_NUMBER_ERROR = "error/IS_ROUTING_NUMBER";
-var isRoutingNumber = createValidator(IS_ROUTING_NUMBER, IS_ROUTING_NUMBER_ERROR);
+};
 
-validatorFns[IS_ROUTING_NUMBER] = function (value, args, form) {
+// based on http://www.brainjar.com/js/validation/
+const IS_ROUTING_NUMBER = "validator/IS_ROUTING_NUMBER";
+const IS_ROUTING_NUMBER_ERROR = "error/IS_ROUTING_NUMBER";
+const isRoutingNumber = createValidator(
+  IS_ROUTING_NUMBER,
+  IS_ROUTING_NUMBER_ERROR
+);
+validatorFns[IS_ROUTING_NUMBER] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   if (value.length != 9) {
     return false;
   }
-
-  var sum = value.split("").map(function (ch) {
-    return parseInt(ch);
-  }).reduce(function (acc, cur, idx) {
-    switch (idx % 3) {
-      case 0:
-        return acc + 3 * cur;
-
-      case 1:
-        return acc + 7 * cur;
-
-      case 2:
-        return acc + 1 * cur;
-    }
-  }, 0);
+  const sum = value
+    .split("")
+    .map(ch => parseInt(ch))
+    .reduce((acc, cur, idx) => {
+      switch (idx % 3) {
+        case 0:
+          return acc + 3 * cur;
+        case 1:
+          return acc + 7 * cur;
+        case 2:
+          return acc + 1 * cur;
+      }
+    }, 0);
   return sum != 0 && sum % 10 == 0;
 };
 
-var HAS_NUMBER = "validator/HAS_NUMBER";
-var HAS_NUMBER_ERROR$1 = "error/HAS_NUMBER";
-var hasNumber = createValidator(HAS_NUMBER, HAS_NUMBER_ERROR$1);
-
-validatorFns[HAS_NUMBER] = function (value, args, form) {
+const HAS_NUMBER = "validator/HAS_NUMBER";
+const HAS_NUMBER_ERROR$1 = "error/HAS_NUMBER";
+const hasNumber = createValidator(HAS_NUMBER, HAS_NUMBER_ERROR$1);
+validatorFns[HAS_NUMBER] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return new RegExp(/[0-9]/).test(value);
 };
 
-var HAS_LOWERCASE_LETTER = "validator/HAS_LOWERCASE_LETTER";
-var HAS_LOWERCASE_LETTER_ERROR$1 = "error/HAS_LOWERCASE_LETTER";
-var hasLowercaseLetter = createValidator(HAS_LOWERCASE_LETTER, HAS_LOWERCASE_LETTER_ERROR$1);
-
-validatorFns[HAS_LOWERCASE_LETTER] = function (value, args, form) {
+const HAS_LOWERCASE_LETTER = "validator/HAS_LOWERCASE_LETTER";
+const HAS_LOWERCASE_LETTER_ERROR$1 = "error/HAS_LOWERCASE_LETTER";
+const hasLowercaseLetter = createValidator(
+  HAS_LOWERCASE_LETTER,
+  HAS_LOWERCASE_LETTER_ERROR$1
+);
+validatorFns[HAS_LOWERCASE_LETTER] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return new RegExp(/[a-z]/).test(value);
 };
 
-var HAS_UPPERCASE_LETTER = "validator/HAS_UPPERCASE_LETTER";
-var HAS_UPPERCASE_LETTER_ERROR$1 = "error/HAS_UPPERCASE_LETTER";
-var hasUppercaseLetter = createValidator(HAS_UPPERCASE_LETTER, HAS_UPPERCASE_LETTER_ERROR$1);
-
-validatorFns[HAS_UPPERCASE_LETTER] = function (value, args, form) {
+const HAS_UPPERCASE_LETTER = "validator/HAS_UPPERCASE_LETTER";
+const HAS_UPPERCASE_LETTER_ERROR$1 = "error/HAS_UPPERCASE_LETTER";
+const hasUppercaseLetter = createValidator(
+  HAS_UPPERCASE_LETTER,
+  HAS_UPPERCASE_LETTER_ERROR$1
+);
+validatorFns[HAS_UPPERCASE_LETTER] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return new RegExp(/[A-Z]/).test(value);
 };
 
-var HAS_SPECIAL_CHARACTER = "validator/HAS_SPECIAL_CHARACTER";
-var HAS_SPECIAL_CHARACTER_ERROR$1 = "error/HAS_SPECIAL_CHARACTER";
-var hasSpecialCharacter = createValidator(HAS_SPECIAL_CHARACTER, HAS_SPECIAL_CHARACTER_ERROR$1);
-
-validatorFns[HAS_SPECIAL_CHARACTER] = function (value, args, form) {
+const HAS_SPECIAL_CHARACTER = "validator/HAS_SPECIAL_CHARACTER";
+const HAS_SPECIAL_CHARACTER_ERROR$1 = "error/HAS_SPECIAL_CHARACTER";
+const hasSpecialCharacter = createValidator(
+  HAS_SPECIAL_CHARACTER,
+  HAS_SPECIAL_CHARACTER_ERROR$1
+);
+validatorFns[HAS_SPECIAL_CHARACTER] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return new RegExp(/[!@#$%^&*.?]/).test(value);
 };
 
-var IS_PROBABLY_EMAIL = "validator/IS_PROBABLY_EMAIL";
-var IS_PROBABLY_EMAIL_ERROR = "error/IS_PROBABLY_EMAIL";
-var isProbablyEmail = createValidator(IS_PROBABLY_EMAIL, IS_PROBABLY_EMAIL_ERROR);
-
-validatorFns[IS_PROBABLY_EMAIL] = function (value, args, form) {
+const IS_PROBABLY_EMAIL = "validator/IS_PROBABLY_EMAIL";
+const IS_PROBABLY_EMAIL_ERROR = "error/IS_PROBABLY_EMAIL";
+const isProbablyEmail = createValidator(
+  IS_PROBABLY_EMAIL,
+  IS_PROBABLY_EMAIL_ERROR
+);
+validatorFns[IS_PROBABLY_EMAIL] = (value, args, form) => {
   if (value === "") {
     return true;
   }
-
   return new RegExp(/^\S+@\S+\.\S+$/).test(value);
 };
 
-var runValidatorErrorMessage = function runValidatorErrorMessage(type) {
-  return "".concat(type, " was passed to runValidator, but that validator type does not exist. \n  Please check that you are only calling validator creator functions exported from \n  redux-freeform in your form config and that you didn't forget to \n  invoke the validator creator (you cannot pass the functions themselves to \n  createFormState)");
-};
-
-var runValidator = function runValidator(validator, value, form) {
-  var validatorFn = validatorFns[validator.type];
+const runValidatorErrorMessage = type =>
+  `${type} was passed to runValidator, but that validator type does not exist. 
+  Please check that you are only calling validator creator functions exported from 
+  redux-freeform in your form config and that you didn't forget to 
+  invoke the validator creator (you cannot pass the functions themselves to 
+  createFormState)`;
 
+const runValidator = (validator, value, form) => {
+  const validatorFn = validatorFns[validator.type];
   if (validatorFn === undefined) {
     throw new Error(runValidatorErrorMessage(validator.type));
   }
-
   return validatorFn(value, validator.args, form) ? null : validator.error;
 };
 
-var _computeErrors = function _computeErrors(fieldName, form, validators) {
-  return validators.map(function (v) {
-    return runValidator(v, form[fieldName].rawValue, form);
-  }).filter(function (x) {
-    return x !== null;
-  });
+const _computeErrors = (fieldName, form, validators) => {
+  return validators
+    .map(v => runValidator(v, form[fieldName].rawValue, form))
+    .filter(x => x !== null);
 };
 
-var computeConstraints = function computeConstraints(fieldName, form) {
-  var constraints = form[fieldName].constraints;
+const computeConstraints = (fieldName, form) => {
+  const constraints = form[fieldName].constraints;
   return _computeErrors(fieldName, form, constraints);
 };
 
-var computeErrors = function computeErrors(fieldName, form) {
-  var validators = form[fieldName].validators;
+const computeErrors = (fieldName, form) => {
+  const validators = form[fieldName].validators;
   return _computeErrors(fieldName, form, validators);
 };
 
 var obj;
-var NOTHING = typeof Symbol !== "undefined" ? Symbol("immer-nothing") : (obj = {}, obj["immer-nothing"] = true, obj);
-var DRAFTABLE = typeof Symbol !== "undefined" && Symbol["for"] ? Symbol["for"]("immer-draftable") : "__$immer_draftable";
-var DRAFT_STATE = typeof Symbol !== "undefined" && Symbol["for"] ? Symbol["for"]("immer-state") : "__$immer_state";
-
+var NOTHING = typeof Symbol !== "undefined" ? Symbol("immer-nothing") : ( obj = {}, obj["immer-nothing"] = true, obj );
+var DRAFTABLE = typeof Symbol !== "undefined" && Symbol.for ? Symbol.for("immer-draftable") : "__$immer_draftable";
+var DRAFT_STATE = typeof Symbol !== "undefined" && Symbol.for ? Symbol.for("immer-state") : "__$immer_state";
 function isDraft(value) {
   return !!value && !!value[DRAFT_STATE];
 }
-
 function isDraftable(value) {
-  if (!value) {
-    return false;
-  }
-
+  if (!value) { return false; }
   return isPlainObject(value) || !!value[DRAFTABLE] || !!value.constructor[DRAFTABLE];
 }
-
 function isPlainObject(value) {
-  if (!value || _typeof(value) !== "object") {
-    return false;
-  }
-
-  if (Array.isArray(value)) {
-    return true;
-  }
-
+  if (!value || typeof value !== "object") { return false; }
+  if (Array.isArray(value)) { return true; }
   var proto = Object.getPrototypeOf(value);
   return !proto || proto === Object.prototype;
 }
-
 var assign = Object.assign || function assign(target, value) {
   for (var key in value) {
     if (has(value, key)) {
@@ -30976,18 +30896,11 @@ var assign = Object.assign || function assign(target, value) {
 
   return target;
 };
-
-var ownKeys$1 = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? function (obj) {
-  return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj));
-} : Object.getOwnPropertyNames;
-
+var ownKeys$1 = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? function (obj) { return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj)); } : Object.getOwnPropertyNames;
 function shallowCopy(base, invokeGetters) {
-  if (invokeGetters === void 0) invokeGetters = false;
-
-  if (Array.isArray(base)) {
-    return base.slice();
-  }
+  if ( invokeGetters === void 0 ) invokeGetters = false;
 
+  if (Array.isArray(base)) { return base.slice(); }
   var clone = Object.create(Object.getPrototypeOf(base));
   ownKeys$1(base).forEach(function (key) {
     if (key === DRAFT_STATE) {
@@ -31017,28 +30930,20 @@ function shallowCopy(base, invokeGetters) {
   });
   return clone;
 }
-
 function each(value, cb) {
   if (Array.isArray(value)) {
-    for (var i = 0; i < value.length; i++) {
-      cb(i, value[i], value);
-    }
+    for (var i = 0; i < value.length; i++) { cb(i, value[i], value); }
   } else {
-    ownKeys$1(value).forEach(function (key) {
-      return cb(key, value[key], value);
-    });
+    ownKeys$1(value).forEach(function (key) { return cb(key, value[key], value); });
   }
 }
-
 function isEnumerable(base, prop) {
   var desc = Object.getOwnPropertyDescriptor(base, prop);
   return !!desc && desc.enumerable;
 }
-
 function has(thing, prop) {
   return Object.prototype.hasOwnProperty.call(thing, prop);
 }
-
 function is(x, y) {
   // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js
   if (x === y) {
@@ -31047,26 +30952,17 @@ function is(x, y) {
     return x !== x && y !== y;
   }
 }
-
 function clone(obj) {
-  if (!isDraftable(obj)) {
-    return obj;
-  }
-
-  if (Array.isArray(obj)) {
-    return obj.map(clone);
-  }
-
+  if (!isDraftable(obj)) { return obj; }
+  if (Array.isArray(obj)) { return obj.map(clone); }
   var cloned = Object.create(Object.getPrototypeOf(obj));
 
-  for (var key in obj) {
-    cloned[key] = clone(obj[key]);
-  }
+  for (var key in obj) { cloned[key] = clone(obj[key]); }
 
   return cloned;
 }
-/** Each scope represents a `produce` call. */
 
+/** Each scope represents a `produce` call. */
 
 var ImmerScope = function ImmerScope(parent) {
   this.drafts = [];
@@ -31078,7 +30974,7 @@ var ImmerScope = function ImmerScope(parent) {
   this.patches = null;
 };
 
-ImmerScope.prototype.usePatches = function usePatches(patchListener) {
+ImmerScope.prototype.usePatches = function usePatches (patchListener) {
   if (patchListener) {
     this.patches = [];
     this.inversePatches = [];
@@ -31086,18 +30982,17 @@ ImmerScope.prototype.usePatches = function usePatches(patchListener) {
   }
 };
 
-ImmerScope.prototype.revoke = function revoke$1() {
+ImmerScope.prototype.revoke = function revoke$1 () {
   this.leave();
   this.drafts.forEach(revoke);
   this.drafts = null; // Make draft-related methods throw.
 };
 
-ImmerScope.prototype.leave = function leave() {
+ImmerScope.prototype.leave = function leave () {
   if (this === ImmerScope.current) {
     ImmerScope.current = this.parent;
   }
 };
-
 ImmerScope.current = null;
 
 ImmerScope.enter = function () {
@@ -31106,11 +31001,11 @@ ImmerScope.enter = function () {
 
 function revoke(draft) {
   draft[DRAFT_STATE].revoke();
-} // but share them all instead
+}
 
+// but share them all instead
 
 var descriptors = {};
-
 function willFinalize(scope, result, isReplaced) {
   scope.drafts.forEach(function (draft) {
     draft[DRAFT_STATE].finalizing = true;
@@ -31128,7 +31023,6 @@ function willFinalize(scope, result, isReplaced) {
       markChangesSweep(scope.drafts);
     }
 }
-
 function createProxy(base, parent) {
   var isArray = Array.isArray(base);
   var draft = clonePotentialDraft(base);
@@ -31182,11 +31076,7 @@ function peek(draft, prop) {
 function get(state, prop) {
   assertUnrevoked(state);
   var value = peek(source(state), prop);
-
-  if (state.finalizing) {
-    return value;
-  } // Create a draft if the value is unmodified.
-
+  if (state.finalizing) { return value; } // Create a draft if the value is unmodified.
 
   if (value === peek(state.base, prop) && isDraftable(value)) {
     prepareCopy(state);
@@ -31201,10 +31091,7 @@ function set(state, prop, value) {
   state.assigned[prop] = true;
 
   if (!state.modified) {
-    if (is(value, peek(source(state), prop))) {
-      return;
-    }
-
+    if (is(value, peek(source(state), prop))) { return; }
     markChanged(state);
     prepareCopy(state);
   }
@@ -31215,17 +31102,12 @@ function set(state, prop, value) {
 function markChanged(state) {
   if (!state.modified) {
     state.modified = true;
-
-    if (state.parent) {
-      markChanged(state.parent);
-    }
+    if (state.parent) { markChanged(state.parent); }
   }
 }
 
 function prepareCopy(state) {
-  if (!state.copy) {
-    state.copy = clonePotentialDraft(state.base);
-  }
+  if (!state.copy) { state.copy = clonePotentialDraft(state.base); }
 }
 
 function clonePotentialDraft(base) {
@@ -31250,12 +31132,15 @@ function proxyProperty(draft, prop, enumerable) {
     descriptors[prop] = desc = {
       configurable: true,
       enumerable: enumerable,
+
       get: function get$1() {
         return get(this[DRAFT_STATE], prop);
       },
+
       set: function set$1(value) {
         set(this[DRAFT_STATE], prop, value);
       }
+
     };
   }
 
@@ -31263,9 +31148,7 @@ function proxyProperty(draft, prop, enumerable) {
 }
 
 function assertUnrevoked(state) {
-  if (state.revoked === true) {
-    throw new Error("Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + JSON.stringify(source(state)));
-  }
+  if (state.revoked === true) { throw new Error("Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + JSON.stringify(source(state))); }
 } // This looks expensive, but only proxies are visited, and only objects without known changes are scanned.
 
 
@@ -31279,27 +31162,16 @@ function markChangesSweep(drafts) {
 
     if (!state.modified) {
       if (Array.isArray(state.base)) {
-        if (hasArrayChanges(state)) {
-          markChanged(state);
-        }
-      } else if (hasObjectChanges(state)) {
-        markChanged(state);
-      }
+        if (hasArrayChanges(state)) { markChanged(state); }
+      } else if (hasObjectChanges(state)) { markChanged(state); }
     }
   }
 }
 
 function markChangesRecursively(object) {
-  if (!object || _typeof(object) !== "object") {
-    return;
-  }
-
+  if (!object || typeof object !== "object") { return; }
   var state = object[DRAFT_STATE];
-
-  if (!state) {
-    return;
-  }
-
+  if (!state) { return; }
   var base = state.base;
   var draft = state.draft;
   var assigned = state.assigned;
@@ -31329,20 +31201,14 @@ function markChangesRecursively(object) {
     assigned.length = true;
 
     if (draft.length < base.length) {
-      for (var i = draft.length; i < base.length; i++) {
-        assigned[i] = false;
-      }
+      for (var i = draft.length; i < base.length; i++) { assigned[i] = false; }
     } else {
-      for (var i$1 = base.length; i$1 < draft.length; i$1++) {
-        assigned[i$1] = true;
-      }
+      for (var i$1 = base.length; i$1 < draft.length; i$1++) { assigned[i$1] = true; }
     }
 
     for (var i$2 = 0; i$2 < draft.length; i$2++) {
       // Only untouched indices trigger recursion.
-      if (assigned[i$2] === undefined) {
-        markChangesRecursively(draft[i$2]);
-      }
+      if (assigned[i$2] === undefined) { markChangesRecursively(draft[i$2]); }
     }
   }
 }
@@ -31379,10 +31245,7 @@ function hasObjectChanges(state) {
 
 function hasArrayChanges(state) {
   var draft = state.draft;
-
-  if (draft.length !== state.base.length) {
-    return true;
-  } // See #116
+  if (draft.length !== state.base.length) { return true; } // See #116
   // If we first shorten the length, our array interceptors will be removed.
   // If after that new items are added, result in the same original length,
   // those last items will have no intercepting property.
@@ -31390,13 +31253,9 @@ function hasArrayChanges(state) {
   // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check
   // the last one
 
-
   var descriptor = Object.getOwnPropertyDescriptor(draft, draft.length - 1); // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10)
 
-  if (descriptor && !descriptor.get) {
-    return true;
-  } // For all other cases, we don't have to compare, as they would have been picked up by the index setters
-
+  if (descriptor && !descriptor.get) { return true; } // For all other cases, we don't have to compare, as they would have been picked up by the index setters
 
   return false;
 }
@@ -31410,12 +31269,11 @@ function createHiddenProperty(target, prop, value) {
 }
 
 var legacyProxy = /*#__PURE__*/Object.freeze({
-  willFinalize: willFinalize,
-  createProxy: createProxy
+	willFinalize: willFinalize,
+	createProxy: createProxy
 });
 
 function willFinalize$1() {}
-
 function createProxy$1(base, parent) {
   var scope = parent ? parent.scope : ImmerScope.current;
   var state = {
@@ -31450,27 +31308,33 @@ function createProxy$1(base, parent) {
   scope.drafts.push(proxy);
   return proxy;
 }
-
 var objectTraps = {
   get: get$1,
+
   has: function has(target, prop) {
     return prop in source$1(target);
   },
+
   ownKeys: function ownKeys(target) {
     return Reflect.ownKeys(source$1(target));
   },
+
   set: set$1,
   deleteProperty: deleteProperty,
   getOwnPropertyDescriptor: getOwnPropertyDescriptor,
+
   defineProperty: function defineProperty() {
     throw new Error("Object.defineProperty() cannot be used on an Immer draft"); // prettier-ignore
   },
+
   getPrototypeOf: function getPrototypeOf(target) {
     return Object.getPrototypeOf(target.base);
   },
+
   setPrototypeOf: function setPrototypeOf() {
     throw new Error("Object.setPrototypeOf() cannot be used on an Immer draft"); // prettier-ignore
   }
+
 };
 var arrayTraps = {};
 each(objectTraps, function (key, fn) {
@@ -31509,10 +31373,7 @@ function peek$1(draft, prop) {
 }
 
 function get$1(state, prop) {
-  if (prop === DRAFT_STATE) {
-    return state;
-  }
-
+  if (prop === DRAFT_STATE) { return state; }
   var drafts = state.drafts; // Check for existing draft in unmodified state.
 
   if (!state.modified && has(drafts, prop)) {
@@ -31528,10 +31389,7 @@ function get$1(state, prop) {
 
   if (state.modified) {
     // Assigned values are never drafted. This catches any drafts we created, too.
-    if (value !== peek$1(state.base, prop)) {
-      return value;
-    } // Store drafts on the copy (when one exists).
-
+    if (value !== peek$1(state.base, prop)) { return value; } // Store drafts on the copy (when one exists).
 
     drafts = state.copy;
   }
@@ -31546,11 +31404,7 @@ function set$1(state, prop, value) {
     // values may be drafts, but falsy values are never drafts.
 
     var isUnchanged = value ? is(baseValue, value) || value === state.drafts[prop] : is(baseValue, value) && prop in state.base;
-
-    if (isUnchanged) {
-      return true;
-    }
-
+    if (isUnchanged) { return true; }
     markChanged$1(state);
   }
 
@@ -31569,10 +31423,7 @@ function deleteProperty(state, prop) {
     delete state.assigned[prop];
   }
 
-  if (state.copy) {
-    delete state.copy[prop];
-  }
-
+  if (state.copy) { delete state.copy[prop]; }
   return true;
 } // Note: We never coerce `desc.value` into an Immer draft, because we can't make
 // the same guarantee in ES5 mode.
@@ -31595,16 +31446,13 @@ function markChanged$1(state) {
     state.modified = true;
     state.copy = assign(shallowCopy(state.base), state.drafts);
     state.drafts = null;
-
-    if (state.parent) {
-      markChanged$1(state.parent);
-    }
+    if (state.parent) { markChanged$1(state.parent); }
   }
 }
 
 var modernProxy = /*#__PURE__*/Object.freeze({
-  willFinalize: willFinalize$1,
-  createProxy: createProxy$1
+	willFinalize: willFinalize$1,
+	createProxy: createProxy$1
 });
 
 function generatePatches(state, basePath, patches, inversePatches) {
@@ -31613,13 +31461,14 @@ function generatePatches(state, basePath, patches, inversePatches) {
 
 function generateArrayPatches(state, basePath, patches, inversePatches) {
   var assign, assign$1;
+
   var base = state.base;
   var copy = state.copy;
   var assigned = state.assigned; // Reduce complexity by ensuring `base` is never longer.
 
   if (copy.length < base.length) {
-    assign = [copy, base], base = assign[0], copy = assign[1];
-    assign$1 = [inversePatches, patches], patches = assign$1[0], inversePatches = assign$1[1];
+    (assign = [copy, base], base = assign[0], copy = assign[1]);
+    (assign$1 = [inversePatches, patches], patches = assign$1[0], inversePatches = assign$1[1]);
   }
 
   var delta = copy.length - base.length; // Find the first replaced index.
@@ -31677,11 +31526,7 @@ function generateObjectPatches(state, basePath, patches, inversePatches) {
     var origValue = base[key];
     var value = copy[key];
     var op = !assignedValue ? "remove" : key in base ? "replace" : "add";
-
-    if (origValue === value && op === "replace") {
-      return;
-    }
-
+    if (origValue === value && op === "replace") { return; }
     var path = basePath.concat(key);
     patches.push(op === "remove" ? {
       op: op,
@@ -31706,26 +31551,20 @@ function generateObjectPatches(state, basePath, patches, inversePatches) {
   });
 }
 
-var applyPatches = function applyPatches(draft, patches) {
+var applyPatches = function (draft, patches) {
   for (var i$1 = 0, list = patches; i$1 < list.length; i$1 += 1) {
     var patch = list[i$1];
+
     var path = patch.path;
     var op = patch.op;
     var value = clone(patch.value); // used to clone patch to ensure original patch is not modified, see #411
 
-    if (!path.length) {
-      throw new Error("Illegal state");
-    }
-
+    if (!path.length) { throw new Error("Illegal state"); }
     var base = draft;
 
     for (var i = 0; i < path.length - 1; i++) {
       base = base[path[i]];
-
-      if (!base || _typeof(base) !== "object") {
-        throw new Error("Cannot apply patch, path doesn't resolve: " + path.join("/"));
-      } // prettier-ignore
-
+      if (!base || typeof base !== "object") { throw new Error("Cannot apply patch, path doesn't resolve: " + path.join("/")); } // prettier-ignore
     }
 
     var key = path[path.length - 1];
@@ -31774,33 +31613,27 @@ var configDefaults = {
   onDelete: null,
   onCopy: null
 };
-
 var Immer = function Immer(config) {
   assign(this, configDefaults, config);
   this.setUseProxies(this.useProxies);
   this.produce = this.produce.bind(this);
 };
 
-Immer.prototype.produce = function produce(base, recipe, patchListener) {
-  var this$1 = this; // curried invocation
+Immer.prototype.produce = function produce (base, recipe, patchListener) {
+    var this$1 = this;
 
+  // curried invocation
   if (typeof base === "function" && typeof recipe !== "function") {
     var defaultBase = recipe;
     recipe = base;
     var self = this;
     return function curriedProduce(base) {
-      var this$1 = this;
-      if (base === void 0) base = defaultBase;
-      var args = [],
-          len = arguments.length - 1;
+        var this$1 = this;
+        if ( base === void 0 ) base = defaultBase;
+        var args = [], len = arguments.length - 1;
+        while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
 
-      while (len-- > 0) {
-        args[len] = arguments[len + 1];
-      }
-
-      return self.produce(base, function (draft) {
-        return recipe.call.apply(recipe, [this$1, draft].concat(args));
-      }); // prettier-ignore
+      return self.produce(base, function (draft) { return recipe.call.apply(recipe, [ this$1, draft ].concat( args )); }); // prettier-ignore
     };
   } // prettier-ignore
 
@@ -31826,11 +31659,7 @@ Immer.prototype.produce = function produce(base, recipe, patchListener) {
       hasError = false;
     } finally {
       // finally instead of catch + rethrow better preserves original stack
-      if (hasError) {
-        scope.revoke();
-      } else {
-        scope.leave();
-      }
+      if (hasError) { scope.revoke(); }else { scope.leave(); }
     }
 
     if (result instanceof Promise) {
@@ -31847,38 +31676,25 @@ Immer.prototype.produce = function produce(base, recipe, patchListener) {
     return this.processResult(result, scope);
   } else {
     result = recipe(base);
-
-    if (result === undefined) {
-      return base;
-    }
-
+    if (result === undefined) { return base; }
     return result !== NOTHING ? result : undefined;
   }
 };
 
-Immer.prototype.produceWithPatches = function produceWithPatches(arg1, arg2, arg3) {
-  var this$1 = this;
+Immer.prototype.produceWithPatches = function produceWithPatches (arg1, arg2, arg3) {
+    var this$1 = this;
 
   if (typeof arg1 === "function") {
     return function (state) {
-      var args = [],
-          len = arguments.length - 1;
+        var args = [], len = arguments.length - 1;
+        while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
 
-      while (len-- > 0) {
-        args[len] = arguments[len + 1];
-      }
-
-      return this$1.produceWithPatches(state, function (draft) {
-        return arg1.apply(void 0, [draft].concat(args));
-      });
-    };
+        return this$1.produceWithPatches(state, function (draft) { return arg1.apply(void 0, [ draft ].concat( args )); });
+      };
   } // non-curried form
 
 
-  if (arg3) {
-    throw new Error("A patch listener cannot be passed to produceWithPatches");
-  }
-
+  if (arg3) { throw new Error("A patch listener cannot be passed to produceWithPatches"); }
   var patches, inversePatches;
   var nextState = this.produce(arg1, arg2, function (p, ip) {
     patches = p;
@@ -31887,7 +31703,7 @@ Immer.prototype.produceWithPatches = function produceWithPatches(arg1, arg2, arg
   return [nextState, patches, inversePatches];
 };
 
-Immer.prototype.createDraft = function createDraft(base) {
+Immer.prototype.createDraft = function createDraft (base) {
   if (!isDraftable(base)) {
     throw new Error("First argument to `createDraft` must be a plain object, an array, or an immerable object"); // prettier-ignore
   }
@@ -31899,7 +31715,7 @@ Immer.prototype.createDraft = function createDraft(base) {
   return proxy;
 };
 
-Immer.prototype.finishDraft = function finishDraft(draft, patchListener) {
+Immer.prototype.finishDraft = function finishDraft (draft, patchListener) {
   var state = draft && draft[DRAFT_STATE];
 
   if (!state || !state.isManual) {
@@ -31915,16 +31731,16 @@ Immer.prototype.finishDraft = function finishDraft(draft, patchListener) {
   return this.processResult(undefined, scope);
 };
 
-Immer.prototype.setAutoFreeze = function setAutoFreeze(value) {
+Immer.prototype.setAutoFreeze = function setAutoFreeze (value) {
   this.autoFreeze = value;
 };
 
-Immer.prototype.setUseProxies = function setUseProxies(value) {
+Immer.prototype.setUseProxies = function setUseProxies (value) {
   this.useProxies = value;
   assign(this, value ? modernProxy : legacyProxy);
 };
 
-Immer.prototype.applyPatches = function applyPatches$1(base, patches) {
+Immer.prototype.applyPatches = function applyPatches$1 (base, patches) {
   // If a patch replaces the entire state, take that replacement as base
   // before applying patches
   var i;
@@ -31944,14 +31760,12 @@ Immer.prototype.applyPatches = function applyPatches$1(base, patches) {
   } // Otherwise, produce a copy of the base state.
 
 
-  return this.produce(base, function (draft) {
-    return applyPatches(draft, patches.slice(i + 1));
-  });
+  return this.produce(base, function (draft) { return applyPatches(draft, patches.slice(i + 1)); });
 };
 /** @internal */
 
 
-Immer.prototype.processResult = function processResult(result, scope) {
+Immer.prototype.processResult = function processResult (result, scope) {
   var baseDraft = scope.drafts[0];
   var isReplaced = result !== undefined && result !== baseDraft;
   this.willFinalize(scope, result, isReplaced);
@@ -31999,15 +31813,13 @@ Immer.prototype.processResult = function processResult(result, scope) {
  */
 
 
-Immer.prototype.finalize = function finalize(draft, path, scope) {
-  var this$1 = this;
+Immer.prototype.finalize = function finalize (draft, path, scope) {
+    var this$1 = this;
+
   var state = draft[DRAFT_STATE];
 
   if (!state) {
-    if (Object.isFrozen(draft)) {
-      return draft;
-    }
-
+    if (Object.isFrozen(draft)) { return draft; }
     return this.finalizeTree(draft, null, scope);
   } // Never finalize drafts owned by another scope.
 
@@ -32030,17 +31842,13 @@ Immer.prototype.finalize = function finalize(draft, path, scope) {
         var assigned = state.assigned;
 
         for (var prop in assigned) {
-          if (!assigned[prop]) {
-            this.onDelete(state, prop);
-          }
+          if (!assigned[prop]) { this.onDelete(state, prop); }
         }
       } else {
         var base = state.base;
-        var copy = state.copy;
+          var copy = state.copy;
         each(base, function (prop) {
-          if (!has(copy, prop)) {
-            this$1.onDelete(state, prop);
-          }
+          if (!has(copy, prop)) { this$1.onDelete(state, prop); }
         });
       }
     }
@@ -32068,8 +31876,9 @@ Immer.prototype.finalize = function finalize(draft, path, scope) {
  */
 
 
-Immer.prototype.finalizeTree = function finalizeTree(root, rootPath, scope) {
-  var this$1 = this;
+Immer.prototype.finalizeTree = function finalizeTree (root, rootPath, scope) {
+    var this$1 = this;
+
   var state = root[DRAFT_STATE];
 
   if (state) {
@@ -32083,7 +31892,7 @@ Immer.prototype.finalizeTree = function finalizeTree(root, rootPath, scope) {
 
   var needPatches = !!rootPath && !!scope.patches;
 
-  var finalizeProperty = function finalizeProperty(prop, value, parent) {
+  var finalizeProperty = function (prop, value, parent) {
     if (value === parent) {
       throw Error("Immer forbids circular references");
     } // In the `finalizeTree` method, only the `root` object may be a draft.
@@ -32110,9 +31919,7 @@ Immer.prototype.finalizeTree = function finalizeTree(root, rootPath, scope) {
       } // Unchanged drafts are never passed to the `onAssign` hook.
 
 
-      if (isDraftProp && value === state.base[prop]) {
-        return;
-      }
+      if (isDraftProp && value === state.base[prop]) { return; }
     } // Unchanged draft properties are ignored.
     else if (isDraftProp && is(value, state.base[prop])) {
         return;
@@ -32197,149 +32004,103 @@ var createDraft = immer.createDraft.bind(immer);
 
 var finishDraft = immer.finishDraft.bind(immer);
 
-var createInitialState = function createInitialState(formConfig) {
-  var initialForm = {};
-  var formConfigKeys = Object.keys(formConfig);
-
-  for (var _i = 0, _formConfigKeys = formConfigKeys; _i < _formConfigKeys.length; _i++) {
-    var formKey = _formConfigKeys[_i];
+const createInitialState = formConfig => {
+  let initialForm = {};
+  const formConfigKeys = Object.keys(formConfig);
+  for (let formKey of formConfigKeys) {
     initialForm[formKey] = {
       dirty: false,
       rawValue: formConfig[formKey].defaultValue || "",
       validators: formConfig[formKey].validators || [],
       constraints: formConfig[formKey].constraints || []
     };
-  } // Because validators require the entire form we have to do a
+  }
+  // Because validators require the entire form we have to do a
   // second pass to add errors once the initial form has been
   // constructed
-
-
-  for (var _i2 = 0, _formConfigKeys2 = formConfigKeys; _i2 < _formConfigKeys2.length; _i2++) {
-    var _formKey = _formConfigKeys2[_i2];
-    var errors = computeErrors(_formKey, initialForm);
-    initialForm[_formKey].errors = errors;
-    initialForm[_formKey].hasErrors = errors.length > 0;
+  for (let formKey of formConfigKeys) {
+    let errors = computeErrors(formKey, initialForm);
+    initialForm[formKey].errors = errors;
+    initialForm[formKey].hasErrors = errors.length > 0;
   }
-
   return initialForm;
 };
 
-var SET = "field/SET";
-
-var set$2 = function set$2(fieldName) {
-  return function (value) {
-    return {
-      type: SET,
-      payload: {
-        fieldName: fieldName,
-        value: value
-      }
-    };
-  };
-};
-
-var CLEAR = "form/CLEAR";
-
-var _clear = function clear() {
-  return {
-    type: CLEAR
-  };
-};
-
-var createFormReducer = function createFormReducer(formConfig) {
-  return function () {
-    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : createInitialState(formConfig);
-    var action = arguments.length > 1 ? arguments[1] : undefined;
-
-    switch (action.type) {
-      case SET:
-        var changedFieldName = action.payload.fieldName;
-        var newRawValue = action.payload.value;
-        return produce(state, function (draftState) {
-          var originalValue = draftState[changedFieldName].rawValue;
-          draftState[changedFieldName].rawValue = newRawValue;
-
-          if (computeConstraints(changedFieldName, draftState).length > 0) {
-            // If the change violates constraints, revert the change
-            draftState[changedFieldName].rawValue = originalValue;
-            return draftState;
-          }
-
-          var fields = Object.entries(draftState);
-
-          for (var _i3 = 0, _fields = fields; _i3 < _fields.length; _i3++) {
-            var entry = _fields[_i3];
-            var fieldName = entry[0];
-            var field = entry[1];
-            var errors = computeErrors(fieldName, draftState);
-            var dirty = fieldName === changedFieldName ? true : field.dirty;
-            draftState[fieldName].errors = errors;
-            draftState[fieldName].dirty = dirty;
-            draftState[fieldName].hasErrors = errors.length > 0;
-          }
-        });
+const SET = "field/SET";
+const set$2 = fieldName => value => ({
+  type: SET,
+  payload: { fieldName, value }
+});
 
-      case CLEAR:
-        return createInitialState(formConfig);
+const CLEAR = "form/CLEAR";
+const clear = () => ({ type: CLEAR });
+
+const createFormReducer = formConfig => (
+  state = createInitialState(formConfig),
+  action
+) => {
+  switch (action.type) {
+    case SET:
+      const changedFieldName = action.payload.fieldName;
+      const newRawValue = action.payload.value;
+
+      return produce(state, draftState => {
+        let originalValue = draftState[changedFieldName].rawValue;
+        draftState[changedFieldName].rawValue = newRawValue;
+        if (computeConstraints(changedFieldName, draftState).length > 0) {
+          // If the change violates constraints, revert the change
+          draftState[changedFieldName].rawValue = originalValue;
+          return draftState;
+        }
 
-      default:
-        return state;
-    }
-  };
+        const fields = Object.entries(draftState);
+        for (let entry of fields) {
+          let fieldName = entry[0];
+          let field = entry[1];
+          let errors = computeErrors(fieldName, draftState);
+          let dirty = fieldName === changedFieldName ? true : field.dirty;
+          draftState[fieldName].errors = errors;
+          draftState[fieldName].dirty = dirty;
+          draftState[fieldName].hasErrors = errors.length > 0;
+        }
+      });
+    case CLEAR:
+      return createInitialState(formConfig);
+    default:
+      return state;
+  }
 };
 
-var createMapDispatchToProps = function createMapDispatchToProps(formConfig) {
+const createMapDispatchToProps = formConfig => {
   // Do memo-ization
-  var cachedDispatch;
-  var cacheValue;
-  return function (dispatch) {
+  let cachedDispatch;
+  let cacheValue;
+  return dispatch => {
     if (dispatch == cachedDispatch) {
       return cacheValue;
     }
-
-    var dispatchObj = {};
+    let dispatchObj = {};
     dispatchObj.fields = {};
-    var keys = Object.keys(formConfig);
-
-    var _loop = function _loop() {
-      var fieldName = _keys[_i4];
+    const keys = Object.keys(formConfig);
+    for (let fieldName of keys) {
       dispatchObj.fields[fieldName] = {
-        set: function set(value) {
-          return dispatch(set$2(fieldName)(value));
-        }
+        set: value => dispatch(set$2(fieldName)(value))
       };
-    };
-
-    for (var _i4 = 0, _keys = keys; _i4 < _keys.length; _i4++) {
-      _loop();
     }
-
-    dispatchObj.form = {
-      clear: function clear() {
-        return dispatch(_clear());
-      }
-    };
+    dispatchObj.form = { clear: () => dispatch(clear()) };
     cachedDispatch = dispatch;
-    cacheValue = {
-      actions: dispatchObj
-    };
+    cacheValue = { actions: dispatchObj };
     return cacheValue;
   };
 };
 
-var mapStateToProps = function mapStateToProps(state) {
-  return {
-    fields: state
-  };
-};
+const mapStateToProps = state => ({ fields: state });
 
-var createFormState = function createFormState(formConfig) {
-  return {
-    reducer: createFormReducer(formConfig),
-    mapDispatchToProps: createMapDispatchToProps(formConfig),
-    mapStateToProps: mapStateToProps
-  };
-};
+const createFormState = formConfig => ({
+  reducer: createFormReducer(formConfig),
+  mapDispatchToProps: createMapDispatchToProps(formConfig),
+  mapStateToProps: mapStateToProps
+});
 
 var formatDelimiter = "_";
 var phoneFormats = ["", "_", "__", "(___) ", "(___) _", "(___) __", "(___) ___-", "(___) ___-_", "(___) ___-__", "(___) ___-___", "(___) ___-____"];