@thecb/components 3.5.6 → 3.5.7

package/dist/index.cjs.js

@@ -215,6 +215,63 @@ 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.
 
@@ -30516,378 +30573,401 @@ var ToggleSwitch = function ToggleSwitch(_ref6) {
 
 var ToggleSwitch$1 = themeComponent(ToggleSwitch, "ToggleSwitch", fallbackValues$o);
 
-const validatorToPredicate = (validatorFn, emptyCase) => (
-  value,
-  ...rest
-) => (value === "" ? emptyCase : validatorFn(value, ...rest));
+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];
+    }
 
+    return value === "" ? emptyCase : validatorFn.apply(void 0, [value].concat(rest));
+  };
+};
 /* eslint-disable no-unused-vars */
 
-const createValidator = (type, error) => {
-  let validator = (...args) => ({ type, args, error });
+
+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
+    };
+  };
+
   validator.error = error;
   return validator;
 };
 
-let validatorFns = {};
+var validatorFns = {};
+var REQUIRED = "validator/REQUIRED";
+var REQUIRED_ERROR = "error/REQUIRED";
+var required = createValidator(REQUIRED, REQUIRED_ERROR);
 
-const REQUIRED = "validator/REQUIRED";
-const REQUIRED_ERROR = "error/REQUIRED";
-const required = createValidator(REQUIRED, REQUIRED_ERROR);
-validatorFns[REQUIRED] = (value, args, form) => value !== "";
+validatorFns[REQUIRED] = function (value, args, form) {
+  return value !== "";
+};
 
-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);
+var ONLY_INTEGERS = "validator/ONLY_INTEGERS";
+var ONLY_INTEGERS_ERROR = "error/ONLY_INTEGERS";
+var onlyIntegers = createValidator(ONLY_INTEGERS, ONLY_INTEGERS_ERROR);
 
-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);
+validatorFns[ONLY_INTEGERS] = function (value, args, form) {
+  return /^(-?\d+)?$/.test(value);
+};
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return Number(value) < args[0];
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return Number(value) <= args[0];
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return Number(value) > args[0];
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return Number(value) >= args[0];
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   if (form[args[0]] === undefined) {
-    throw new Error(
-      `${args[0]} was passed to matchesField, but that field does not exist in the form`
-    );
+    throw new Error("".concat(args[0], " was passed to matchesField, but that field does not exist in the form"));
   }
+
   return value === form[args[0]].rawValue;
 };
 
-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
-});
+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
+  };
+};
+
 validateWhen.error = VALIDATE_WHEN_ERROR;
-validatorFns[VALIDATE_WHEN] = (value, args, form) => {
-  const [dependentValidator, primaryValidator, optionalFieldName] = args;
-  const dependsOnOtherField = typeof optionalFieldName === "string";
 
-  if (
-    primaryValidator.type === undefined ||
-    typeof validatorFns[primaryValidator.type] !== "function"
-  ) {
+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") {
     throw new Error(validateWhenErrorMessage(primaryValidator.type));
   }
+
   if (dependsOnOtherField && form[optionalFieldName] === undefined) {
-    throw new Error(
-      `${args[2]} was passed to matchesField, but that field does not exist in the form`
-    );
+    throw new Error("".concat(args[2], " was passed to matchesField, but that field does not exist in the form"));
   }
 
-  const primaryPredicate = validatorToPredicate(
-    validatorFns[primaryValidator.type],
-    false
-  );
-  const primaryValue = dependsOnOtherField
-    ? form[optionalFieldName].rawValue
-    : value;
-  const primaryPredicatePassed = primaryPredicate(
-    primaryValue,
-    primaryValidator.args,
-    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
+  };
+};
 
-  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;
 
-  if (
-    validator.type === undefined ||
-    typeof validatorFns[validator.type] !== "function"
-  ) {
+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") {
     throw new Error(validateSumErrorMessage(validator.type));
   }
 
-  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`
-      );
+  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"));
+      }
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
 
-  const sum = fieldNamesArray.reduce(
-    (acc, curr) => acc + Number(form[curr].rawValue),
-    Number(value)
-  );
-
+  var sum = fieldNamesArray.reduce(function (acc, curr) {
+    return acc + Number(form[curr].rawValue);
+  }, Number(value));
   return validatorFns[validator.type](sum, validator.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) => {
+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) {
   if (value === "") {
     return true;
   }
-  const min = args[0];
-  const max = args[1];
+
+  var min = args[0];
+  var 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");
   }
-  const valueLength = value.length;
+
+  var valueLength = value.length;
   return max >= valueLength && valueLength >= min;
 };
 
-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) => {
+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) {
   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/
 
-// 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) => {
+
+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) {
   if (value === "") {
     return true;
   }
+
   if (value.length != 9) {
     return false;
   }
-  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);
+
+  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);
   return sum != 0 && sum % 10 == 0;
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return new RegExp(/[0-9]/).test(value);
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return new RegExp(/[a-z]/).test(value);
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return new RegExp(/[A-Z]/).test(value);
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return new RegExp(/[!@#$%^&*.?]/).test(value);
 };
 
-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) => {
+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) {
   if (value === "") {
     return true;
   }
+
   return new RegExp(/^\S+@\S+\.\S+$/).test(value);
 };
 
-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)`;
+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 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;
 };
 
-const _computeErrors = (fieldName, form, validators) => {
-  return validators
-    .map(v => runValidator(v, form[fieldName].rawValue, form))
-    .filter(x => x !== null);
+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 computeConstraints = (fieldName, form) => {
-  const constraints = form[fieldName].constraints;
+var computeConstraints = function computeConstraints(fieldName, form) {
+  var constraints = form[fieldName].constraints;
   return _computeErrors(fieldName, form, constraints);
 };
 
-const computeErrors = (fieldName, form) => {
-  const validators = form[fieldName].validators;
+var computeErrors = function computeErrors(fieldName, form) {
+  var 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)) {
@@ -30897,11 +30977,18 @@ 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 (invokeGetters === void 0) invokeGetters = false;
+
+  if (Array.isArray(base)) {
+    return base.slice();
+  }
 
-  if (Array.isArray(base)) { return base.slice(); }
   var clone = Object.create(Object.getPrototypeOf(base));
   ownKeys$1(base).forEach(function (key) {
     if (key === DRAFT_STATE) {
@@ -30931,20 +31018,28 @@ 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) {
@@ -30953,18 +31048,27 @@ 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. */
 
+
 var ImmerScope = function ImmerScope(parent) {
   this.drafts = [];
   this.parent = parent; // Whenever the modified draft contains a draft from another scope, we
@@ -30975,7 +31079,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 = [];
@@ -30983,17 +31087,18 @@ 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 () {
@@ -31002,11 +31107,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;
@@ -31024,6 +31129,7 @@ function willFinalize(scope, result, isReplaced) {
       markChangesSweep(scope.drafts);
     }
 }
+
 function createProxy(base, parent) {
   var isArray = Array.isArray(base);
   var draft = clonePotentialDraft(base);
@@ -31077,7 +31183,11 @@ 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);
@@ -31092,7 +31202,10 @@ 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);
   }
@@ -31103,12 +31216,17 @@ 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) {
@@ -31133,15 +31251,12 @@ 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);
       }
-
     };
   }
 
@@ -31149,7 +31264,9 @@ 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.
 
 
@@ -31163,16 +31280,27 @@ 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;
@@ -31202,14 +31330,20 @@ 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]);
+      }
     }
   }
 }
@@ -31246,7 +31380,10 @@ 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.
@@ -31254,9 +31391,13 @@ 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;
 }
@@ -31270,11 +31411,12 @@ 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 = {
@@ -31309,33 +31451,27 @@ 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) {
@@ -31374,7 +31510,10 @@ 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)) {
@@ -31390,7 +31529,10 @@ 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;
   }
@@ -31405,7 +31547,11 @@ 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);
   }
 
@@ -31424,7 +31570,10 @@ 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.
@@ -31447,13 +31596,16 @@ 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) {
@@ -31462,14 +31614,13 @@ 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.
@@ -31527,7 +31678,11 @@ 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,
@@ -31552,20 +31707,26 @@ function generateObjectPatches(state, basePath, patches, inversePatches) {
   });
 }
 
-var applyPatches = function (draft, patches) {
+var applyPatches = function applyPatches(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];
@@ -31614,27 +31775,33 @@ 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;
+Immer.prototype.produce = function produce(base, recipe, patchListener) {
+  var this$1 = this; // curried invocation
 
-  // 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;
-        while ( len-- > 0 ) args[ len ] = arguments[ len + 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];
+      }
 
-      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
 
@@ -31660,7 +31827,11 @@ 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) {
@@ -31677,25 +31848,38 @@ 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;
-        while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
+      var args = [],
+          len = arguments.length - 1;
 
-        return this$1.produceWithPatches(state, function (draft) { return arg1.apply(void 0, [ draft ].concat( args )); });
-      };
+      while (len-- > 0) {
+        args[len] = arguments[len + 1];
+      }
+
+      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;
@@ -31704,7 +31888,7 @@ Immer.prototype.produceWithPatches = function produceWithPatches (arg1, arg2, ar
   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
   }
@@ -31716,7 +31900,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) {
@@ -31732,16 +31916,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;
@@ -31761,12 +31945,14 @@ 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);
@@ -31814,13 +32000,15 @@ 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.
 
@@ -31843,13 +32031,17 @@ 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);
+          }
         });
       }
     }
@@ -31877,9 +32069,8 @@ 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) {
@@ -31893,7 +32084,7 @@ Immer.prototype.finalizeTree = function finalizeTree (root, rootPath, scope) {
 
   var needPatches = !!rootPath && !!scope.patches;
 
-  var finalizeProperty = function (prop, value, parent) {
+  var finalizeProperty = function finalizeProperty(prop, value, parent) {
     if (value === parent) {
       throw Error("Immer forbids circular references");
     } // In the `finalizeTree` method, only the `root` object may be a draft.
@@ -31920,7 +32111,9 @@ 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;
@@ -32005,103 +32198,149 @@ var createDraft = immer.createDraft.bind(immer);
 
 var finishDraft = immer.finishDraft.bind(immer);
 
-const createInitialState = formConfig => {
-  let initialForm = {};
-  const formConfigKeys = Object.keys(formConfig);
-  for (let formKey of formConfigKeys) {
+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];
     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 (let formKey of formConfigKeys) {
-    let errors = computeErrors(formKey, initialForm);
-    initialForm[formKey].errors = errors;
-    initialForm[formKey].hasErrors = errors.length > 0;
+
+
+  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;
   }
+
   return initialForm;
 };
 
-const SET = "field/SET";
-const set$2 = fieldName => value => ({
-  type: SET,
-  payload: { fieldName, value }
-});
+var SET = "field/SET";
 
-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;
-        }
+var set$2 = function set$2(fieldName) {
+  return function (value) {
+    return {
+      type: SET,
+      payload: {
+        fieldName: fieldName,
+        value: value
+      }
+    };
+  };
+};
 
-        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 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;
+          }
+        });
+
+      case CLEAR:
+        return createInitialState(formConfig);
+
+      default:
+        return state;
+    }
+  };
 };
 
-const createMapDispatchToProps = formConfig => {
+var createMapDispatchToProps = function createMapDispatchToProps(formConfig) {
   // Do memo-ization
-  let cachedDispatch;
-  let cacheValue;
-  return dispatch => {
+  var cachedDispatch;
+  var cacheValue;
+  return function (dispatch) {
     if (dispatch == cachedDispatch) {
       return cacheValue;
     }
-    let dispatchObj = {};
+
+    var dispatchObj = {};
     dispatchObj.fields = {};
-    const keys = Object.keys(formConfig);
-    for (let fieldName of keys) {
+    var keys = Object.keys(formConfig);
+
+    var _loop = function _loop() {
+      var fieldName = _keys[_i4];
       dispatchObj.fields[fieldName] = {
-        set: value => dispatch(set$2(fieldName)(value))
+        set: function set(value) {
+          return dispatch(set$2(fieldName)(value));
+        }
       };
+    };
+
+    for (var _i4 = 0, _keys = keys; _i4 < _keys.length; _i4++) {
+      _loop();
     }
-    dispatchObj.form = { clear: () => dispatch(clear()) };
+
+    dispatchObj.form = {
+      clear: function clear() {
+        return dispatch(_clear());
+      }
+    };
     cachedDispatch = dispatch;
-    cacheValue = { actions: dispatchObj };
+    cacheValue = {
+      actions: dispatchObj
+    };
     return cacheValue;
   };
 };
 
-const mapStateToProps = state => ({ fields: state });
+var mapStateToProps = function mapStateToProps(state) {
+  return {
+    fields: state
+  };
+};
 
-const createFormState = formConfig => ({
-  reducer: createFormReducer(formConfig),
-  mapDispatchToProps: createMapDispatchToProps(formConfig),
-  mapStateToProps: mapStateToProps
-});
+var createFormState = function createFormState(formConfig) {
+  return {
+    reducer: createFormReducer(formConfig),
+    mapDispatchToProps: createMapDispatchToProps(formConfig),
+    mapStateToProps: mapStateToProps
+  };
+};
 
 var formatDelimiter = "_";
 var phoneFormats = ["", "_", "__", "(___) ", "(___) _", "(___) __", "(___) ___-", "(___) ___-_", "(___) ___-__", "(___) ___-___", "(___) ___-____"];
@@ -36772,7 +37011,7 @@ var PaymentFormACH = function PaymentFormACH(_ref) {
 
   var confirmRoutingNumberErrors = _defineProperty({}, matchesField.error, "Confirm routing number field must match routing number");
 
-  var accountNumberErrors = (_accountNumberErrors = {}, _defineProperty(_accountNumberErrors, required.error, "Account number is required"), _defineProperty(_accountNumberErrors, hasLength.error, "Account number must be between 6 and 17 digits"), _accountNumberErrors);
+  var accountNumberErrors = (_accountNumberErrors = {}, _defineProperty(_accountNumberErrors, required.error, "Account number is required"), _defineProperty(_accountNumberErrors, hasLength.error, "Account number must be between 5 and 17 digits"), _accountNumberErrors);
 
   var confirmAccountNumberErrors = _defineProperty({}, matchesField.error, "Confirm account number field must match account number");
 
@@ -36902,7 +37141,7 @@ var formConfig$6 = {
     constraints: [onlyIntegers(), hasLength(0, 9)]
   },
   accountNumber: {
-    validators: [required(), hasLength(6, 17)],
+    validators: [required(), hasLength(5, 17)],
     constraints: [onlyIntegers(), hasLength(0, 17)]
   },
   confirmAccountNumber: {