@thecb/components 5.7.0-beta.4 → 5.7.0-beta.5

package/dist/index.esm.js

@@ -33962,10 +33962,1008 @@ const TypeaheadInput = ({
   }));
 };
 
-const validatorToPredicate = (validatorFn, emptyCase) => (
-  value,
-  ...rest
-) => (value === "" ? emptyCase : validatorFn(value, ...rest));
+// makes subclassing work correct for wrapped built-ins
+var inheritIfRequired = function ($this, dummy, Wrapper) {
+  var NewTarget, NewTargetPrototype;
+  if (
+    // it can work only with native `setPrototypeOf`
+    objectSetPrototypeOf &&
+    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
+    isCallable(NewTarget = dummy.constructor) &&
+    NewTarget !== Wrapper &&
+    isObject(NewTargetPrototype = NewTarget.prototype) &&
+    NewTargetPrototype !== Wrapper.prototype
+  ) objectSetPrototypeOf($this, NewTargetPrototype);
+  return $this;
+};
+
+var valueOf = 1.0.valueOf;
+
+// `thisNumberValue` abstract operation
+// https://tc39.es/ecma262/#sec-thisnumbervalue
+var thisNumberValue = function (value) {
+  return valueOf.call(value);
+};
+
+// a string of all valid unicode whitespaces
+var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
+  '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
+
+var whitespace = '[' + whitespaces + ']';
+var ltrim = RegExp('^' + whitespace + whitespace + '*');
+var rtrim = RegExp(whitespace + whitespace + '*$');
+
+// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
+var createMethod$2 = function (TYPE) {
+  return function ($this) {
+    var string = toString_1(requireObjectCoercible($this));
+    if (TYPE & 1) string = string.replace(ltrim, '');
+    if (TYPE & 2) string = string.replace(rtrim, '');
+    return string;
+  };
+};
+
+var stringTrim = {
+  // `String.prototype.{ trimLeft, trimStart }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimstart
+  start: createMethod$2(1),
+  // `String.prototype.{ trimRight, trimEnd }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimend
+  end: createMethod$2(2),
+  // `String.prototype.trim` method
+  // https://tc39.es/ecma262/#sec-string.prototype.trim
+  trim: createMethod$2(3)
+};
+
+var getOwnPropertyNames = objectGetOwnPropertyNames.f;
+var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
+var defineProperty$1 = objectDefineProperty.f;
+
+var trim = stringTrim.trim;
+
+var NUMBER = 'Number';
+var NativeNumber = global_1[NUMBER];
+var NumberPrototype = NativeNumber.prototype;
+
+// `ToNumeric` abstract operation
+// https://tc39.es/ecma262/#sec-tonumeric
+var toNumeric = function (value) {
+  var primValue = toPrimitive(value, 'number');
+  return typeof primValue === 'bigint' ? primValue : toNumber(primValue);
+};
+
+// `ToNumber` abstract operation
+// https://tc39.es/ecma262/#sec-tonumber
+var toNumber = function (argument) {
+  var it = toPrimitive(argument, 'number');
+  var first, third, radix, maxCode, digits, length, index, code;
+  if (isSymbol(it)) throw TypeError('Cannot convert a Symbol value to a number');
+  if (typeof it == 'string' && it.length > 2) {
+    it = trim(it);
+    first = it.charCodeAt(0);
+    if (first === 43 || first === 45) {
+      third = it.charCodeAt(2);
+      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
+    } else if (first === 48) {
+      switch (it.charCodeAt(1)) {
+        case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i
+        case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i
+        default: return +it;
+      }
+      digits = it.slice(2);
+      length = digits.length;
+      for (index = 0; index < length; index++) {
+        code = digits.charCodeAt(index);
+        // parseInt parses a string to a first unavailable symbol
+        // but ToNumber should return NaN if a string contains unavailable symbols
+        if (code < 48 || code > maxCode) return NaN;
+      } return parseInt(digits, radix);
+    }
+  } return +it;
+};
+
+// `Number` constructor
+// https://tc39.es/ecma262/#sec-number-constructor
+if (isForced_1(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) {
+  var NumberWrapper = function Number(value) {
+    var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value));
+    var dummy = this;
+    // check on 1..constructor(foo) case
+    return dummy instanceof NumberWrapper && fails(function () { thisNumberValue(dummy); })
+      ? inheritIfRequired(Object(n), dummy, NumberWrapper) : n;
+  };
+  for (var keys$2 = descriptors ? getOwnPropertyNames(NativeNumber) : (
+    // ES3:
+    'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
+    // ES2015 (in case, if modules with ES2015 Number statics required before):
+    'EPSILON,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,isFinite,isInteger,isNaN,isSafeInteger,parseFloat,parseInt,' +
+    // ESNext
+    'fromString,range'
+  ).split(','), j = 0, key; keys$2.length > j; j++) {
+    if (hasOwnProperty_1(NativeNumber, key = keys$2[j]) && !hasOwnProperty_1(NumberWrapper, key)) {
+      defineProperty$1(NumberWrapper, key, getOwnPropertyDescriptor$2(NativeNumber, key));
+    }
+  }
+  NumberWrapper.prototype = NumberPrototype;
+  NumberPrototype.constructor = NumberWrapper;
+  redefine(global_1, NUMBER, NumberWrapper);
+}
+
+// `Array.prototype.{ reduce, reduceRight }` methods implementation
+var createMethod$3 = function (IS_RIGHT) {
+  return function (that, callbackfn, argumentsLength, memo) {
+    aCallable(callbackfn);
+    var O = toObject(that);
+    var self = indexedObject(O);
+    var length = lengthOfArrayLike(O);
+    var index = IS_RIGHT ? length - 1 : 0;
+    var i = IS_RIGHT ? -1 : 1;
+    if (argumentsLength < 2) while (true) {
+      if (index in self) {
+        memo = self[index];
+        index += i;
+        break;
+      }
+      index += i;
+      if (IS_RIGHT ? index < 0 : length <= index) {
+        throw TypeError('Reduce of empty array with no initial value');
+      }
+    }
+    for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
+      memo = callbackfn(memo, self[index], index, O);
+    }
+    return memo;
+  };
+};
+
+var arrayReduce = {
+  // `Array.prototype.reduce` method
+  // https://tc39.es/ecma262/#sec-array.prototype.reduce
+  left: createMethod$3(false),
+  // `Array.prototype.reduceRight` method
+  // https://tc39.es/ecma262/#sec-array.prototype.reduceright
+  right: createMethod$3(true)
+};
+
+var arrayMethodIsStrict = function (METHOD_NAME, argument) {
+  var method = [][METHOD_NAME];
+  return !!method && fails(function () {
+    // eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing
+    method.call(null, argument || function () { throw 1; }, 1);
+  });
+};
+
+var engineIsNode = classofRaw(global_1.process) == 'process';
+
+var $reduce = arrayReduce.left;
+
+
+
+
+var STRICT_METHOD = arrayMethodIsStrict('reduce');
+// Chrome 80-82 has a critical bug
+// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
+var CHROME_BUG = !engineIsNode && engineV8Version > 79 && engineV8Version < 83;
+
+// `Array.prototype.reduce` method
+// https://tc39.es/ecma262/#sec-array.prototype.reduce
+_export({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, {
+  reduce: function reduce(callbackfn /* , initialValue */) {
+    return $reduce(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+// `Object.prototype.toString` method implementation
+// https://tc39.es/ecma262/#sec-object.prototype.tostring
+var objectToString = toStringTagSupport ? {}.toString : function toString() {
+  return '[object ' + classof(this) + ']';
+};
+
+// `Object.prototype.toString` method
+// https://tc39.es/ecma262/#sec-object.prototype.tostring
+if (!toStringTagSupport) {
+  redefine(Object.prototype, 'toString', objectToString, { unsafe: true });
+}
+
+var trim$1 = stringTrim.trim;
+
+
+var $parseInt = global_1.parseInt;
+var Symbol$2 = global_1.Symbol;
+var ITERATOR$3 = Symbol$2 && Symbol$2.iterator;
+var hex$1 = /^[+-]?0x/i;
+var FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22
+  // MS Edge 18- broken with boxed symbols
+  || (ITERATOR$3 && !fails(function () { $parseInt(Object(ITERATOR$3)); }));
+
+// `parseInt` method
+// https://tc39.es/ecma262/#sec-parseint-string-radix
+var numberParseInt = FORCED ? function parseInt(string, radix) {
+  var S = trim$1(toString_1(string));
+  return $parseInt(S, (radix >>> 0) || (hex$1.test(S) ? 16 : 10));
+} : $parseInt;
+
+// `parseInt` method
+// https://tc39.es/ecma262/#sec-parseint-string-radix
+_export({ global: true, forced: parseInt != numberParseInt }, {
+  parseInt: numberParseInt
+});
+
+// `IsArray` abstract operation
+// https://tc39.es/ecma262/#sec-isarray
+// eslint-disable-next-line es/no-array-isarray -- safe
+var isArray = Array.isArray || function isArray(argument) {
+  return classofRaw(argument) == 'Array';
+};
+
+var empty = [];
+var construct = getBuiltIn('Reflect', 'construct');
+var constructorRegExp = /^\s*(?:class|function)\b/;
+var exec = constructorRegExp.exec;
+var INCORRECT_TO_STRING = !constructorRegExp.exec(function () { /* empty */ });
+
+var isConstructorModern = function (argument) {
+  if (!isCallable(argument)) return false;
+  try {
+    construct(Object, empty, argument);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+var isConstructorLegacy = function (argument) {
+  if (!isCallable(argument)) return false;
+  switch (classof(argument)) {
+    case 'AsyncFunction':
+    case 'GeneratorFunction':
+    case 'AsyncGeneratorFunction': return false;
+    // we can't check .prototype since constructors produced by .bind haven't it
+  } return INCORRECT_TO_STRING || !!exec.call(constructorRegExp, inspectSource(argument));
+};
+
+// `IsConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-isconstructor
+var isConstructor = !construct || fails(function () {
+  var called;
+  return isConstructorModern(isConstructorModern.call)
+    || !isConstructorModern(Object)
+    || !isConstructorModern(function () { called = true; })
+    || called;
+}) ? isConstructorLegacy : isConstructorModern;
+
+var createProperty = function (object, key, value) {
+  var propertyKey = toPropertyKey(key);
+  if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value));
+  else object[propertyKey] = value;
+};
+
+var SPECIES$1 = wellKnownSymbol('species');
+
+var arrayMethodHasSpeciesSupport = function (METHOD_NAME) {
+  // We can't use this feature detection in V8 since it causes
+  // deoptimization and serious performance degradation
+  // https://github.com/zloirock/core-js/issues/677
+  return engineV8Version >= 51 || !fails(function () {
+    var array = [];
+    var constructor = array.constructor = {};
+    constructor[SPECIES$1] = function () {
+      return { foo: 1 };
+    };
+    return array[METHOD_NAME](Boolean).foo !== 1;
+  });
+};
+
+var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');
+
+var SPECIES$2 = wellKnownSymbol('species');
+var nativeSlice = [].slice;
+var max$2 = Math.max;
+
+// `Array.prototype.slice` method
+// https://tc39.es/ecma262/#sec-array.prototype.slice
+// fallback for not array-like ES3 strings and DOM objects
+_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
+  slice: function slice(start, end) {
+    var O = toIndexedObject(this);
+    var length = lengthOfArrayLike(O);
+    var k = toAbsoluteIndex(start, length);
+    var fin = toAbsoluteIndex(end === undefined ? length : end, length);
+    // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
+    var Constructor, result, n;
+    if (isArray(O)) {
+      Constructor = O.constructor;
+      // cross-realm fallback
+      if (isConstructor(Constructor) && (Constructor === Array || isArray(Constructor.prototype))) {
+        Constructor = undefined;
+      } else if (isObject(Constructor)) {
+        Constructor = Constructor[SPECIES$2];
+        if (Constructor === null) Constructor = undefined;
+      }
+      if (Constructor === Array || Constructor === undefined) {
+        return nativeSlice.call(O, k, fin);
+      }
+    }
+    result = new (Constructor === undefined ? Array : Constructor)(max$2(fin - k, 0));
+    for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
+    result.length = n;
+    return result;
+  }
+});
+
+var MATCH = wellKnownSymbol('match');
+
+// `IsRegExp` abstract operation
+// https://tc39.es/ecma262/#sec-isregexp
+var isRegexp = function (it) {
+  var isRegExp;
+  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp');
+};
+
+var SPECIES$3 = wellKnownSymbol('species');
+
+var setSpecies = function (CONSTRUCTOR_NAME) {
+  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
+  var defineProperty = objectDefineProperty.f;
+
+  if (descriptors && Constructor && !Constructor[SPECIES$3]) {
+    defineProperty(Constructor, SPECIES$3, {
+      configurable: true,
+      get: function () { return this; }
+    });
+  }
+};
+
+var defineProperty$2 = objectDefineProperty.f;
+var getOwnPropertyNames$1 = objectGetOwnPropertyNames.f;
+
+
+
+
+
+
+
+var enforceInternalState = internalState.enforce;
+
+
+
+
+
+var MATCH$1 = wellKnownSymbol('match');
+var NativeRegExp = global_1.RegExp;
+var RegExpPrototype$1 = NativeRegExp.prototype;
+// TODO: Use only propper RegExpIdentifierName
+var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/;
+var re1 = /a/g;
+var re2 = /a/g;
+
+// "new" should create a new object, old webkit bug
+var CORRECT_NEW = new NativeRegExp(re1) !== re1;
+
+var UNSUPPORTED_Y$2 = regexpStickyHelpers.UNSUPPORTED_Y;
+
+var BASE_FORCED = descriptors &&
+  (!CORRECT_NEW || UNSUPPORTED_Y$2 || regexpUnsupportedDotAll || regexpUnsupportedNcg || fails(function () {
+    re2[MATCH$1] = false;
+    // RegExp constructor can alter flags and IsRegExp works correct with @@match
+    return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';
+  }));
+
+var handleDotAll = function (string) {
+  var length = string.length;
+  var index = 0;
+  var result = '';
+  var brackets = false;
+  var chr;
+  for (; index <= length; index++) {
+    chr = string.charAt(index);
+    if (chr === '\\') {
+      result += chr + string.charAt(++index);
+      continue;
+    }
+    if (!brackets && chr === '.') {
+      result += '[\\s\\S]';
+    } else {
+      if (chr === '[') {
+        brackets = true;
+      } else if (chr === ']') {
+        brackets = false;
+      } result += chr;
+    }
+  } return result;
+};
+
+var handleNCG = function (string) {
+  var length = string.length;
+  var index = 0;
+  var result = '';
+  var named = [];
+  var names = {};
+  var brackets = false;
+  var ncg = false;
+  var groupid = 0;
+  var groupname = '';
+  var chr;
+  for (; index <= length; index++) {
+    chr = string.charAt(index);
+    if (chr === '\\') {
+      chr = chr + string.charAt(++index);
+    } else if (chr === ']') {
+      brackets = false;
+    } else if (!brackets) switch (true) {
+      case chr === '[':
+        brackets = true;
+        break;
+      case chr === '(':
+        if (IS_NCG.test(string.slice(index + 1))) {
+          index += 2;
+          ncg = true;
+        }
+        result += chr;
+        groupid++;
+        continue;
+      case chr === '>' && ncg:
+        if (groupname === '' || hasOwnProperty_1(names, groupname)) {
+          throw new SyntaxError('Invalid capture group name');
+        }
+        names[groupname] = true;
+        named.push([groupname, groupid]);
+        ncg = false;
+        groupname = '';
+        continue;
+    }
+    if (ncg) groupname += chr;
+    else result += chr;
+  } return [result, named];
+};
+
+// `RegExp` constructor
+// https://tc39.es/ecma262/#sec-regexp-constructor
+if (isForced_1('RegExp', BASE_FORCED)) {
+  var RegExpWrapper = function RegExp(pattern, flags) {
+    var thisIsRegExp = this instanceof RegExpWrapper;
+    var patternIsRegExp = isRegexp(pattern);
+    var flagsAreUndefined = flags === undefined;
+    var groups = [];
+    var rawPattern = pattern;
+    var rawFlags, dotAll, sticky, handled, result, state;
+
+    if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) {
+      return pattern;
+    }
+
+    if (patternIsRegExp || pattern instanceof RegExpWrapper) {
+      pattern = pattern.source;
+      if (flagsAreUndefined) flags = 'flags' in rawPattern ? rawPattern.flags : regexpFlags.call(rawPattern);
+    }
+
+    pattern = pattern === undefined ? '' : toString_1(pattern);
+    flags = flags === undefined ? '' : toString_1(flags);
+    rawPattern = pattern;
+
+    if (regexpUnsupportedDotAll && 'dotAll' in re1) {
+      dotAll = !!flags && flags.indexOf('s') > -1;
+      if (dotAll) flags = flags.replace(/s/g, '');
+    }
+
+    rawFlags = flags;
+
+    if (UNSUPPORTED_Y$2 && 'sticky' in re1) {
+      sticky = !!flags && flags.indexOf('y') > -1;
+      if (sticky) flags = flags.replace(/y/g, '');
+    }
+
+    if (regexpUnsupportedNcg) {
+      handled = handleNCG(pattern);
+      pattern = handled[0];
+      groups = handled[1];
+    }
+
+    result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype$1, RegExpWrapper);
+
+    if (dotAll || sticky || groups.length) {
+      state = enforceInternalState(result);
+      if (dotAll) {
+        state.dotAll = true;
+        state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);
+      }
+      if (sticky) state.sticky = true;
+      if (groups.length) state.groups = groups;
+    }
+
+    if (pattern !== rawPattern) try {
+      // fails in old engines, but we have no alternatives for unsupported regex syntax
+      createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);
+    } catch (error) { /* empty */ }
+
+    return result;
+  };
+
+  var proxy = function (key) {
+    key in RegExpWrapper || defineProperty$2(RegExpWrapper, key, {
+      configurable: true,
+      get: function () { return NativeRegExp[key]; },
+      set: function (it) { NativeRegExp[key] = it; }
+    });
+  };
+
+  for (var keys$3 = getOwnPropertyNames$1(NativeRegExp), index$4 = 0; keys$3.length > index$4;) {
+    proxy(keys$3[index$4++]);
+  }
+
+  RegExpPrototype$1.constructor = RegExpWrapper;
+  RegExpWrapper.prototype = RegExpPrototype$1;
+  redefine(global_1, 'RegExp', RegExpWrapper);
+}
+
+// https://tc39.es/ecma262/#sec-get-regexp-@@species
+setSpecies('RegExp');
+
+var PROPER_FUNCTION_NAME$1 = functionName.PROPER;
+
+
+
+
+
+
+var TO_STRING = 'toString';
+var RegExpPrototype$2 = RegExp.prototype;
+var nativeToString = RegExpPrototype$2[TO_STRING];
+
+var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
+// FF44- RegExp#toString has a wrong name
+var INCORRECT_NAME = PROPER_FUNCTION_NAME$1 && nativeToString.name != TO_STRING;
+
+// `RegExp.prototype.toString` method
+// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
+if (NOT_GENERIC || INCORRECT_NAME) {
+  redefine(RegExp.prototype, TO_STRING, function toString() {
+    var R = anObject(this);
+    var p = toString_1(R.source);
+    var rf = R.flags;
+    var f = toString_1(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype$2) ? regexpFlags.call(R) : rf);
+    return '/' + p + '/' + f;
+  }, { unsafe: true });
+}
+
+// optional / simple context binding
+var functionBindContext = function (fn, that, length) {
+  aCallable(fn);
+  if (that === undefined) return fn;
+  switch (length) {
+    case 0: return function () {
+      return fn.call(that);
+    };
+    case 1: return function (a) {
+      return fn.call(that, a);
+    };
+    case 2: return function (a, b) {
+      return fn.call(that, a, b);
+    };
+    case 3: return function (a, b, c) {
+      return fn.call(that, a, b, c);
+    };
+  }
+  return function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var SPECIES$4 = wellKnownSymbol('species');
+
+// a part of `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesConstructor = function (originalArray) {
+  var C;
+  if (isArray(originalArray)) {
+    C = originalArray.constructor;
+    // cross-realm fallback
+    if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;
+    else if (isObject(C)) {
+      C = C[SPECIES$4];
+      if (C === null) C = undefined;
+    }
+  } return C === undefined ? Array : C;
+};
+
+// `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesCreate = function (originalArray, length) {
+  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
+};
+
+var push = [].push;
+
+// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
+var createMethod$4 = function (TYPE) {
+  var IS_MAP = TYPE == 1;
+  var IS_FILTER = TYPE == 2;
+  var IS_SOME = TYPE == 3;
+  var IS_EVERY = TYPE == 4;
+  var IS_FIND_INDEX = TYPE == 6;
+  var IS_FILTER_REJECT = TYPE == 7;
+  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+  return function ($this, callbackfn, that, specificCreate) {
+    var O = toObject($this);
+    var self = indexedObject(O);
+    var boundFunction = functionBindContext(callbackfn, that, 3);
+    var length = lengthOfArrayLike(self);
+    var index = 0;
+    var create = specificCreate || arraySpeciesCreate;
+    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
+    var value, result;
+    for (;length > index; index++) if (NO_HOLES || index in self) {
+      value = self[index];
+      result = boundFunction(value, index, O);
+      if (TYPE) {
+        if (IS_MAP) target[index] = result; // map
+        else if (result) switch (TYPE) {
+          case 3: return true;              // some
+          case 5: return value;             // find
+          case 6: return index;             // findIndex
+          case 2: push.call(target, value); // filter
+        } else switch (TYPE) {
+          case 4: return false;             // every
+          case 7: push.call(target, value); // filterReject
+        }
+      }
+    }
+    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
+  };
+};
+
+var arrayIteration = {
+  // `Array.prototype.forEach` method
+  // https://tc39.es/ecma262/#sec-array.prototype.foreach
+  forEach: createMethod$4(0),
+  // `Array.prototype.map` method
+  // https://tc39.es/ecma262/#sec-array.prototype.map
+  map: createMethod$4(1),
+  // `Array.prototype.filter` method
+  // https://tc39.es/ecma262/#sec-array.prototype.filter
+  filter: createMethod$4(2),
+  // `Array.prototype.some` method
+  // https://tc39.es/ecma262/#sec-array.prototype.some
+  some: createMethod$4(3),
+  // `Array.prototype.every` method
+  // https://tc39.es/ecma262/#sec-array.prototype.every
+  every: createMethod$4(4),
+  // `Array.prototype.find` method
+  // https://tc39.es/ecma262/#sec-array.prototype.find
+  find: createMethod$4(5),
+  // `Array.prototype.findIndex` method
+  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
+  findIndex: createMethod$4(6),
+  // `Array.prototype.filterReject` method
+  // https://github.com/tc39/proposal-array-filtering
+  filterReject: createMethod$4(7)
+};
+
+var $map = arrayIteration.map;
+
+
+var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport('map');
+
+// `Array.prototype.map` method
+// https://tc39.es/ecma262/#sec-array.prototype.map
+// with adding support of @@species
+_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, {
+  map: function map(callbackfn /* , thisArg */) {
+    return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+// `Assert: IsConstructor(argument) is true`
+var aConstructor = function (argument) {
+  if (isConstructor(argument)) return argument;
+  throw TypeError(tryToString(argument) + ' is not a constructor');
+};
+
+var SPECIES$5 = wellKnownSymbol('species');
+
+// `SpeciesConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-speciesconstructor
+var speciesConstructor = function (O, defaultConstructor) {
+  var C = anObject(O).constructor;
+  var S;
+  return C === undefined || (S = anObject(C)[SPECIES$5]) == undefined ? defaultConstructor : aConstructor(S);
+};
+
+var UNSUPPORTED_Y$3 = regexpStickyHelpers.UNSUPPORTED_Y;
+var arrayPush = [].push;
+var min$3 = Math.min;
+var MAX_UINT32 = 0xFFFFFFFF;
+
+// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
+// Weex JS has frozen built-in prototypes, so use try / catch wrapper
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
+  // eslint-disable-next-line regexp/no-empty-group -- required for testing
+  var re = /(?:)/;
+  var originalExec = re.exec;
+  re.exec = function () { return originalExec.apply(this, arguments); };
+  var result = 'ab'.split(re);
+  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
+});
+
+// @@split logic
+fixRegexpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
+  var internalSplit;
+  if (
+    'abbc'.split(/(b)*/)[1] == 'c' ||
+    // eslint-disable-next-line regexp/no-empty-group -- required for testing
+    'test'.split(/(?:)/, -1).length != 4 ||
+    'ab'.split(/(?:ab)*/).length != 2 ||
+    '.'.split(/(.?)(.?)/).length != 4 ||
+    // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
+    '.'.split(/()()/).length > 1 ||
+    ''.split(/.?/).length
+  ) {
+    // based on es5-shim implementation, need to rework it
+    internalSplit = function (separator, limit) {
+      var string = toString_1(requireObjectCoercible(this));
+      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
+      if (lim === 0) return [];
+      if (separator === undefined) return [string];
+      // If `separator` is not a regex, use native split
+      if (!isRegexp(separator)) {
+        return nativeSplit.call(string, separator, lim);
+      }
+      var output = [];
+      var flags = (separator.ignoreCase ? 'i' : '') +
+                  (separator.multiline ? 'm' : '') +
+                  (separator.unicode ? 'u' : '') +
+                  (separator.sticky ? 'y' : '');
+      var lastLastIndex = 0;
+      // Make `global` and avoid `lastIndex` issues by working with a copy
+      var separatorCopy = new RegExp(separator.source, flags + 'g');
+      var match, lastIndex, lastLength;
+      while (match = regexpExec.call(separatorCopy, string)) {
+        lastIndex = separatorCopy.lastIndex;
+        if (lastIndex > lastLastIndex) {
+          output.push(string.slice(lastLastIndex, match.index));
+          if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1));
+          lastLength = match[0].length;
+          lastLastIndex = lastIndex;
+          if (output.length >= lim) break;
+        }
+        if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
+      }
+      if (lastLastIndex === string.length) {
+        if (lastLength || !separatorCopy.test('')) output.push('');
+      } else output.push(string.slice(lastLastIndex));
+      return output.length > lim ? output.slice(0, lim) : output;
+    };
+  // Chakra, V8
+  } else if ('0'.split(undefined, 0).length) {
+    internalSplit = function (separator, limit) {
+      return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit);
+    };
+  } else internalSplit = nativeSplit;
+
+  return [
+    // `String.prototype.split` method
+    // https://tc39.es/ecma262/#sec-string.prototype.split
+    function split(separator, limit) {
+      var O = requireObjectCoercible(this);
+      var splitter = separator == undefined ? undefined : getMethod(separator, SPLIT);
+      return splitter
+        ? splitter.call(separator, O, limit)
+        : internalSplit.call(toString_1(O), separator, limit);
+    },
+    // `RegExp.prototype[@@split]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@split
+    //
+    // NOTE: This cannot be properly polyfilled in engines that don't support
+    // the 'y' flag.
+    function (string, limit) {
+      var rx = anObject(this);
+      var S = toString_1(string);
+      var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
+
+      if (res.done) return res.value;
+
+      var C = speciesConstructor(rx, RegExp);
+
+      var unicodeMatching = rx.unicode;
+      var flags = (rx.ignoreCase ? 'i' : '') +
+                  (rx.multiline ? 'm' : '') +
+                  (rx.unicode ? 'u' : '') +
+                  (UNSUPPORTED_Y$3 ? 'g' : 'y');
+
+      // ^(? + rx + ) is needed, in combination with some S slicing, to
+      // simulate the 'y' flag.
+      var splitter = new C(UNSUPPORTED_Y$3 ? '^(?:' + rx.source + ')' : rx, flags);
+      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
+      if (lim === 0) return [];
+      if (S.length === 0) return regexpExecAbstract(splitter, S) === null ? [S] : [];
+      var p = 0;
+      var q = 0;
+      var A = [];
+      while (q < S.length) {
+        splitter.lastIndex = UNSUPPORTED_Y$3 ? 0 : q;
+        var z = regexpExecAbstract(splitter, UNSUPPORTED_Y$3 ? S.slice(q) : S);
+        var e;
+        if (
+          z === null ||
+          (e = min$3(toLength(splitter.lastIndex + (UNSUPPORTED_Y$3 ? q : 0)), S.length)) === p
+        ) {
+          q = advanceStringIndex(S, q, unicodeMatching);
+        } else {
+          A.push(S.slice(p, q));
+          if (A.length === lim) return A;
+          for (var i = 1; i <= z.length - 1; i++) {
+            A.push(z[i]);
+            if (A.length === lim) return A;
+          }
+          q = p = e;
+        }
+      }
+      A.push(S.slice(p));
+      return A;
+    }
+  ];
+}, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y$3);
+
+var $filter = arrayIteration.filter;
+
+
+var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport('filter');
+
+// `Array.prototype.filter` method
+// https://tc39.es/ecma262/#sec-array.prototype.filter
+// with adding support of @@species
+_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, {
+  filter: function filter(callbackfn /* , thisArg */) {
+    return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
+var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
+var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded';
+
+// We can't use this feature detection in V8 since it causes
+// deoptimization and serious performance degradation
+// https://github.com/zloirock/core-js/issues/679
+var IS_CONCAT_SPREADABLE_SUPPORT = engineV8Version >= 51 || !fails(function () {
+  var array = [];
+  array[IS_CONCAT_SPREADABLE] = false;
+  return array.concat()[0] !== array;
+});
+
+var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');
+
+var isConcatSpreadable = function (O) {
+  if (!isObject(O)) return false;
+  var spreadable = O[IS_CONCAT_SPREADABLE];
+  return spreadable !== undefined ? !!spreadable : isArray(O);
+};
+
+var FORCED$1 = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;
+
+// `Array.prototype.concat` method
+// https://tc39.es/ecma262/#sec-array.prototype.concat
+// with adding support of @@isConcatSpreadable and @@species
+_export({ target: 'Array', proto: true, forced: FORCED$1 }, {
+  // eslint-disable-next-line no-unused-vars -- required for `.length`
+  concat: function concat(arg) {
+    var O = toObject(this);
+    var A = arraySpeciesCreate(O, 0);
+    var n = 0;
+    var i, k, length, len, E;
+    for (i = -1, length = arguments.length; i < length; i++) {
+      E = i === -1 ? O : arguments[i];
+      if (isConcatSpreadable(E)) {
+        len = lengthOfArrayLike(E);
+        if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
+        for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);
+      } else {
+        if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
+        createProperty(A, n++, E);
+      }
+    }
+    A.length = n;
+    return A;
+  }
+});
+
+var FAILS_ON_PRIMITIVES = fails(function () { objectKeys(1); });
+
+// `Object.keys` method
+// https://tc39.es/ecma262/#sec-object.keys
+_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
+  keys: function keys(it) {
+    return objectKeys(toObject(it));
+  }
+});
+
+var propertyIsEnumerable = objectPropertyIsEnumerable.f;
+
+// `Object.{ entries, values }` methods implementation
+var createMethod$5 = function (TO_ENTRIES) {
+  return function (it) {
+    var O = toIndexedObject(it);
+    var keys = objectKeys(O);
+    var length = keys.length;
+    var i = 0;
+    var result = [];
+    var key;
+    while (length > i) {
+      key = keys[i++];
+      if (!descriptors || propertyIsEnumerable.call(O, key)) {
+        result.push(TO_ENTRIES ? [key, O[key]] : O[key]);
+      }
+    }
+    return result;
+  };
+};
+
+var objectToArray = {
+  // `Object.entries` method
+  // https://tc39.es/ecma262/#sec-object.entries
+  entries: createMethod$5(true),
+  // `Object.values` method
+  // https://tc39.es/ecma262/#sec-object.values
+  values: createMethod$5(false)
+};
+
+var $entries = objectToArray.entries;
+
+// `Object.entries` method
+// https://tc39.es/ecma262/#sec-object.entries
+_export({ target: 'Object', stat: true }, {
+  entries: function entries(O) {
+    return $entries(O);
+  }
+});
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var 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));
+  };
+};
 
 var commonjsGlobal$1 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -34001,10 +34999,19 @@ var isSameOrAfter$1 = {exports: {}};
 
 var isSameOrAfter = isSameOrAfter$1.exports;
 
-/* eslint-disable no-unused-vars */
+var createValidator = function createValidator(type, error) {
+  var validator = function validator() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return {
+      type: type,
+      args: args,
+      error: error
+    };
+  };
 
-const createValidator = (type, error) => {
-  let validator = (...args) => ({ type, args, error });
   validator.error = error;
   return validator;
 };
@@ -34012,428 +35019,408 @@ const createValidator = (type, error) => {
 dayjs.extend(customParseFormat);
 dayjs.extend(isSameOrBefore);
 dayjs.extend(isSameOrAfter);
+var validatorFns = {};
+var REQUIRED = "validator/REQUIRED";
+var REQUIRED_ERROR = "error/REQUIRED";
+var required = createValidator(REQUIRED, REQUIRED_ERROR);
+
+validatorFns[REQUIRED] = function (value, args, form) {
+  return value !== "";
+};
 
-let validatorFns = {};
+var ONLY_INTEGERS = "validator/ONLY_INTEGERS";
+var ONLY_INTEGERS_ERROR = "error/ONLY_INTEGERS";
+var onlyIntegers = createValidator(ONLY_INTEGERS, ONLY_INTEGERS_ERROR);
 
-const REQUIRED = "validator/REQUIRED";
-const REQUIRED_ERROR = "error/REQUIRED";
-const required = createValidator(REQUIRED, REQUIRED_ERROR);
-validatorFns[REQUIRED] = (value, args, form) => value !== "";
+validatorFns[ONLY_INTEGERS] = function (value, args, form) {
+  return /^(-?\d+)?$/.test(value);
+};
+
+var ONLY_NATURALS = "validator/ONLY_NATURALS";
+var ONLY_NATURALS_ERROR = "error/ONLY_NATURALS";
+var onlyNaturals = createValidator(ONLY_NATURALS, ONLY_NATURALS_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_NATURALS] = 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 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);
 
-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) => {
+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) => {
-  const dependentField = form[args[0]];
-  const dependentFieldValue = dependentField?.rawValue ?? "";
+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) {
+  var _dependentField$rawVa;
+
+  var dependentField = form[args[0]];
+  var dependentFieldValue = (_dependentField$rawVa = dependentField == null ? void 0 : dependentField.rawValue) != null ? _dependentField$rawVa : "";
+
   if (dependentField === undefined) {
-    throw new Error(
-      `${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 === dependentFieldValue;
 };
 
-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 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 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(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 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 validator = args[0],
+      fieldNamesArray = args[1];
+
+  if (validator.type === undefined || typeof validatorFns[validator.type] !== "function") {
     throw new Error(validateSumErrorMessage(validator.type));
   }
 
-  for (const fieldName of fieldNamesArray) {
+  for (var _iterator = _createForOfIteratorHelperLoose(fieldNamesArray), _step; !(_step = _iterator()).done;) {
+    var fieldName = _step.value;
+
     if (form[fieldName] === undefined) {
-      throw new Error(
-        `${fieldName} was passed to matchesField, but that field does not exist in the form`
-      );
+      throw new Error(fieldName + " was passed to matchesField, but that field does not exist in the form");
     }
   }
 
-  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 DATE_BEFORE_TODAY = "validator/DATE_BEFORE_TODAY";
-const DATE_BEFORE_TODAY_ERROR = "error/DATE_BEFORE_TODAY";
-const dateBeforeToday = createValidator(
-  DATE_BEFORE_TODAY,
-  DATE_BEFORE_TODAY_ERROR
-);
-validatorFns[DATE_BEFORE_TODAY] = (value, args, form) => {
+var DATE_BEFORE_TODAY = "validator/DATE_BEFORE_TODAY";
+var DATE_BEFORE_TODAY_ERROR = "error/DATE_BEFORE_TODAY";
+var dateBeforeToday = createValidator(DATE_BEFORE_TODAY, DATE_BEFORE_TODAY_ERROR);
+
+validatorFns[DATE_BEFORE_TODAY] = function (value, args, form) {
   if (value === "") {
     return true;
   }
-  const dateFormat = args[0];
-  const unit = args[1];
-  const inclusive = args[2] || false;
+
+  var dateFormat = args[0];
+  var unit = args[1];
+  var inclusive = args[2] || false;
 
   if (dateFormat == undefined || unit == undefined) {
-    throw new Error(
-      "Date format and unit need to be defined for dateBeforeToday, one or both are undefined"
-    );
+    throw new Error("Date format and unit need to be defined for dateBeforeToday, one or both are undefined");
   }
-  const now = dayjs();
-  const dateValue = dayjs(value, dateFormat);
+
+  var now = dayjs();
+  var dateValue = dayjs(value, dateFormat);
 
   if (inclusive === true) {
     return dateValue.isSameOrBefore(now, unit);
   }
+
   return dateValue.isBefore(now, unit);
 };
 
-const DATE_AFTER_TODAY = "validator/DATE_AFTER_TODAY";
-const DATE_AFTER_TODAY_ERROR = "error/DATE_AFTER_TODAY";
-const dateAfterToday = createValidator(
-  DATE_AFTER_TODAY,
-  DATE_AFTER_TODAY_ERROR
-);
-validatorFns[DATE_AFTER_TODAY] = (value, args, form) => {
+var DATE_AFTER_TODAY = "validator/DATE_AFTER_TODAY";
+var DATE_AFTER_TODAY_ERROR = "error/DATE_AFTER_TODAY";
+var dateAfterToday = createValidator(DATE_AFTER_TODAY, DATE_AFTER_TODAY_ERROR);
+
+validatorFns[DATE_AFTER_TODAY] = function (value, args, form) {
   if (value === "") {
     return true;
   }
-  const dateFormat = args[0];
-  const unit = args[1];
-  const inclusive = args[2] || false;
+
+  var dateFormat = args[0];
+  var unit = args[1];
+  var inclusive = args[2] || false;
 
   if (dateFormat == undefined || unit == undefined) {
-    throw new Error(
-      "Date format and unit need to be defined for dateAfterToday, one or both are undefined"
-    );
+    throw new Error("Date format and unit need to be defined for dateAfterToday, one or both are undefined");
   }
-  const now = dayjs();
-  const dateValue = dayjs(value, dateFormat);
+
+  var now = dayjs();
+  var dateValue = dayjs(value, dateFormat);
 
   if (inclusive === true) {
     return dateValue.isSameOrAfter(now, unit);
   }
+
   return dateValue.isAfter(now, unit);
 };
 
-const IS_VALID_MONTH = "validator/IS_VALID_MONTH";
-const IS_VALID_MONTH_ERROR = "error/IS_VALID_MONTH";
-const isValidMonth = createValidator(
-  IS_VALID_MONTH,
-  IS_VALID_MONTH_ERROR
-);
-validatorFns[IS_VALID_MONTH] = (value, args, form) => {
+var IS_VALID_MONTH = "validator/IS_VALID_MONTH";
+var IS_VALID_MONTH_ERROR = "error/IS_VALID_MONTH";
+var isValidMonth = createValidator(IS_VALID_MONTH, IS_VALID_MONTH_ERROR);
+
+validatorFns[IS_VALID_MONTH] = function (value, args, form) {
   if (value === "") {
     return true;
-  }
-  // Function takes one argument representing the character position
+  } // Function takes one argument representing the character position
   // In a date string to identify where the month is
   // Eg "10/21/2021" - start position is 0
   // Or "18/03/1990" - start position is 3
   // Only works with two digit months (01, 02, 03, etc)
-  const monthStartPosition = parseInt(args[0]);
-  const monthEndPosition = monthStartPosition + 2;
+
+
+  var monthStartPosition = parseInt(args[0]);
+  var monthEndPosition = monthStartPosition + 2;
+
   if (monthStartPosition === NaN) {
     throw new Error("Month start position has to be a valid integer string");
   }
-  const month = parseInt(value.slice(monthStartPosition, monthEndPosition));
+
+  var month = parseInt(value.slice(monthStartPosition, monthEndPosition));
+
   if (month === NaN) {
     return false;
   }
+
   return month >= 1 && month <= 12;
 };
 
-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 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);
 };
 
@@ -34888,7 +35875,7 @@ var objectTraps = {
 
   set: set$1$1,
   deleteProperty: deleteProperty,
-  getOwnPropertyDescriptor: getOwnPropertyDescriptor$2,
+  getOwnPropertyDescriptor: getOwnPropertyDescriptor$3,
 
   defineProperty: function defineProperty() {
     throw new Error("Object.defineProperty() cannot be used on an Immer draft"); // prettier-ignore
@@ -34996,7 +35983,7 @@ function deleteProperty(state, prop) {
 // the same guarantee in ES5 mode.
 
 
-function getOwnPropertyDescriptor$2(state, prop) {
+function getOwnPropertyDescriptor$3(state, prop) {
   var owner = source$1(state);
   var desc = Reflect.getOwnPropertyDescriptor(owner, prop);
 
@@ -35571,127 +36558,179 @@ immer.createDraft.bind(immer);
 
 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;
 };
+var SET = "field/SET";
 
-const SET = "field/SET";
-const set$2 = fieldName => value => ({
-  type: SET,
-  payload: { fieldName, value }
-});
+var _set = function set(fieldName) {
+  return function (value) {
+    return {
+      type: SET,
+      payload: {
+        fieldName: fieldName,
+        value: value
+      }
+    };
+  };
+};
+var CLEAR = "form/CLEAR";
+
+var _clear = function clear() {
+  return {
+    type: CLEAR
+  };
+};
+var ADD_VALIDATOR = "field/ADD_VALIDATOR";
 
-const CLEAR = "form/CLEAR";
-const clear = () => ({ type: CLEAR });
+var _addValidator = function addValidator(fieldName) {
+  return function (validator) {
+    return {
+      type: ADD_VALIDATOR,
+      payload: {
+        fieldName: fieldName,
+        validator: validator
+      }
+    };
+  };
+};
+var createFormReducer = function createFormReducer(formConfig) {
+  return function (state, action) {
+    if (state === void 0) {
+      state = createInitialState(formConfig);
+    }
 
-const ADD_VALIDATOR = "field/ADD_VALIDATOR";
-const addValidator = fieldName => validator => ({
-  type: ADD_VALIDATOR,
-  payload: { fieldName, validator }
-});
+    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;
+          }
 
-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 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 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);
-    case ADD_VALIDATOR: 
-      const fieldWithOverride = action.payload.fieldName;
-      const newValidator = action.payload.validator;
-      
-      return produce(state, draftState => {
-        draftState[fieldWithOverride].validators.push(newValidator);
-        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 = field.dirty;
-          draftState[fieldName].errors = errors;
-          draftState[fieldName].dirty = dirty;
-          draftState[fieldName].hasErrors = errors.length > 0;
-        }
-      });
-    default:
-      return state;
-  }
-};
+      case CLEAR:
+        return createInitialState(formConfig);
+
+      case ADD_VALIDATOR:
+        var fieldWithOverride = action.payload.fieldName;
+        var newValidator = action.payload.validator;
+        return produce(state, function (draftState) {
+          draftState[fieldWithOverride].validators.push(newValidator);
+          var fields = Object.entries(draftState);
+
+          for (var _i4 = 0, _fields2 = fields; _i4 < _fields2.length; _i4++) {
+            var entry = _fields2[_i4];
+            var fieldName = entry[0];
+            var field = entry[1];
+            var errors = computeErrors(fieldName, draftState);
+            var dirty = field.dirty;
+            draftState[fieldName].errors = errors;
+            draftState[fieldName].dirty = dirty;
+            draftState[fieldName].hasErrors = errors.length > 0;
+          }
+        });
 
-const createMapDispatchToProps = formConfig => {
+      default:
+        return state;
+    }
+  };
+};
+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[_i5];
       dispatchObj.fields[fieldName] = {
-        set: value => dispatch(set$2(fieldName)(value)),
-        addValidator: validator => dispatch(addValidator(fieldName)(validator))
+        set: function set(value) {
+          return dispatch(_set(fieldName)(value));
+        },
+        addValidator: function addValidator(validator) {
+          return dispatch(_addValidator(fieldName)(validator));
+        }
       };
+    };
+
+    for (var _i5 = 0, _keys = keys; _i5 < _keys.length; _i5++) {
+      _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 });
-
-const createFormState = formConfig => ({
-  reducer: createFormReducer(formConfig),
-  mapDispatchToProps: createMapDispatchToProps(formConfig),
-  mapStateToProps: mapStateToProps
-});
+var mapStateToProps = function mapStateToProps(state) {
+  return {
+    fields: state
+  };
+};
+var createFormState = function createFormState(formConfig) {
+  return {
+    reducer: createFormReducer(formConfig),
+    mapDispatchToProps: createMapDispatchToProps(formConfig),
+    mapStateToProps: mapStateToProps
+  };
+};
 
 const formatDelimiter = "_";
 const phoneFormats = ["", "_", "__", "(___) ", "(___) _", "(___) __", "(___) ___-", "(___) ___-_", "(___) ___-__", "(___) ___-___", "(___) ___-____"];
@@ -35977,18 +37016,9 @@ ChangePasswordForm.reducer = reducer$1;
 ChangePasswordForm.mapStateToProps = mapStateToProps$2;
 ChangePasswordForm.mapDispatchToProps = mapDispatchToProps$1;
 
-var MATCH = wellKnownSymbol('match');
-
-// `IsRegExp` abstract operation
-// https://tc39.es/ecma262/#sec-isregexp
-var isRegexp = function (it) {
-  var isRegExp;
-  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp');
-};
-
 var REPLACE$1 = wellKnownSymbol('replace');
-var RegExpPrototype$1 = RegExp.prototype;
-var max$2 = Math.max;
+var RegExpPrototype$3 = RegExp.prototype;
+var max$3 = Math.max;
 
 var stringIndexOf = function (string, searchValue, fromIndex) {
   if (fromIndex > string.length) return -1;
@@ -36008,7 +37038,7 @@ _export({ target: 'String', proto: true }, {
     if (searchValue != null) {
       IS_REG_EXP = isRegexp(searchValue);
       if (IS_REG_EXP) {
-        flags = toString_1(requireObjectCoercible('flags' in RegExpPrototype$1
+        flags = toString_1(requireObjectCoercible('flags' in RegExpPrototype$3
           ? searchValue.flags
           : regexpFlags.call(searchValue)
         ));
@@ -36024,7 +37054,7 @@ _export({ target: 'String', proto: true }, {
     functionalReplace = isCallable(replaceValue);
     if (!functionalReplace) replaceValue = toString_1(replaceValue);
     searchLength = searchString.length;
-    advanceBy = max$2(1, searchLength);
+    advanceBy = max$3(1, searchLength);
     position = stringIndexOf(string, searchString, 0);
     while (position !== -1) {
       if (functionalReplace) {
@@ -42221,7 +43251,7 @@ var SidebarStackContent$1 = withWindowSize(themeComponent(SidebarStackContent, "
 
 
 
-var index$4 = /*#__PURE__*/Object.freeze({
+var index$5 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   colors: colors,
   fontWeights: style_constants
@@ -42229,12 +43259,12 @@ var index$4 = /*#__PURE__*/Object.freeze({
 
 
 
-var index$5 = /*#__PURE__*/Object.freeze({
+var index$6 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   formats: formats,
   general: general,
   theme: themeUtils
 });
 
-export { AccountNumberImage, AccountsAddIcon$1 as AccountsAddIcon, AccountsIcon$1 as AccountsIcon, AccountsIconSmall$1 as AccountsIconSmall, AchReturnIcon, AddObligation$1 as AddObligation, AddressForm, Alert$1 as Alert, AllocatedIcon, AmountCallout$1 as AmountCallout, AutopayOnIcon$1 as AutopayOnIcon, BankIcon, Box, BoxWithShadow$1 as BoxWithShadow, Breadcrumbs as Breadcrumb, ButtonWithAction, ButtonWithLink, CalendarIcon, CarrotIcon$1 as CarrotIcon, CashIcon, Center, CenterSingle$1 as CenterSingle, CenterStack$1 as CenterStack, ChangePasswordForm, ChargebackIcon, ChargebackReversalIcon, CheckIcon, Checkbox$1 as Checkbox, CheckboxList$1 as CheckboxList, CheckmarkIcon, ChevronIcon$1 as ChevronIcon, Cluster, CollapsibleSection$1 as CollapsibleSection, CountryDropdown, Cover, CustomerSearchIcon, DefaultPageTemplate, Detail$1 as Detail, DisplayBox$1 as DisplayBox, DisplayCard, Dropdown$1 as Dropdown, DuplicateIcon, EditNameForm, EditableList, EditableTable, EmailForm, EmptyCartIcon$1 as EmptyCartIcon, ErroredIcon, ExternalLink, FailedIcon, ForgotPasswordForm, ForgotPasswordIcon$1 as ForgotPasswordIcon, FormContainer$1 as FormContainer, FormFooterPanel$1 as FormFooterPanel, FormInput$1 as FormInput, FormInputColumn, FormInputRow, FormSelect$1 as FormSelect, FormattedAddress$1 as FormattedAddress, FormattedCreditCard$1 as FormattedCreditCard, Frame, GenericCard, GenericCardLarge, GoToEmailIcon$1 as GoToEmailIcon, Grid, HamburgerButton, Heading$1 as Heading, HighlightTabRow$1 as HighlightTabRow, IconAdd, IconQuitLarge, Imposter, InternalLink, InternalUserInfoForm, Jumbo$1 as Jumbo, LabeledAmount$1 as LabeledAmount, LineItem$1 as LineItem, Loading, LoginForm, Modal$1 as Modal, Module$1 as Module, Motion, NavFooter, NavHeader, NavMenuDesktop$1 as NavMenuDesktop, NavMenuMobile$1 as NavMenuMobile, NoCustomerResultsIcon, NoPaymentResultsIcon, NotFoundIcon, Obligation, iconsMap as ObligationIcons, Pagination, Paragraph$1 as Paragraph, PartialAmountForm, PasswordRequirements, PaymentButtonBar, PaymentDetails$1 as PaymentDetails, PaymentFormACH, PaymentFormCard$1 as PaymentFormCard, PaymentIcon, PaymentMethodAddIcon$1 as PaymentMethodAddIcon, PaymentMethodIcon$1 as PaymentMethodIcon, PaymentSearchIcon, PaymentsIconSmall$1 as PaymentsIconSmall, PendingIcon, PeriscopeFailedIcon, PhoneForm, Placeholder$1 as Placeholder, ProcessingFee$1 as ProcessingFee, ProfileIcon$1 as ProfileIcon, ProfileIconSmall$1 as ProfileIconSmall, PropertiesAddIcon$1 as PropertiesAddIcon, PropertiesIconSmall$1 as PropertiesIconSmall, RadioButton$2 as RadioButton, RadioSection$1 as RadioSection, Reel, RefundIcon, RegistrationForm, RejectedIcon, RejectedVelocityIcon, ResetConfirmationForm$1 as ResetConfirmationForm, ResetPasswordForm, ResetPasswordIcon, ResetPasswordSuccess, RoutingNumberImage, SearchIcon, SearchableSelect$1 as SearchableSelect, SettingsIconSmall$1 as SettingsIconSmall, ShoppingCartIcon, Sidebar, SidebarSingleContent$1 as SidebarSingleContent, SidebarStackContent$1 as SidebarStackContent, SolidDivider$1 as SolidDivider, Spinner$2 as Spinner, Stack, FormStateDropdown as StateProvinceDropdown, StatusUnknownIcon, SuccessfulIcon, Switcher, TabSidebar$1 as TabSidebar, TableListItem, Tabs$1 as Tabs, TermsAndConditions, TermsAndConditionsModal$1 as TermsAndConditionsModal, Text$1 as Text, Timeout$1 as Timeout, TimeoutImage, Title$1 as Title, ToggleSwitch$1 as ToggleSwitch, TrashIcon$1 as TrashIcon, TypeaheadInput, VerifiedEmailIcon$1 as VerifiedEmailIcon, VoidedIcon, WalletIcon$1 as WalletIcon, WarningIconXS, WelcomeModule$1 as WelcomeModule, WorkflowTile, cardRegistry, index$4 as constants, createPartialAmountFormState, index$5 as util, withWindowSize };
+export { AccountNumberImage, AccountsAddIcon$1 as AccountsAddIcon, AccountsIcon$1 as AccountsIcon, AccountsIconSmall$1 as AccountsIconSmall, AchReturnIcon, AddObligation$1 as AddObligation, AddressForm, Alert$1 as Alert, AllocatedIcon, AmountCallout$1 as AmountCallout, AutopayOnIcon$1 as AutopayOnIcon, BankIcon, Box, BoxWithShadow$1 as BoxWithShadow, Breadcrumbs as Breadcrumb, ButtonWithAction, ButtonWithLink, CalendarIcon, CarrotIcon$1 as CarrotIcon, CashIcon, Center, CenterSingle$1 as CenterSingle, CenterStack$1 as CenterStack, ChangePasswordForm, ChargebackIcon, ChargebackReversalIcon, CheckIcon, Checkbox$1 as Checkbox, CheckboxList$1 as CheckboxList, CheckmarkIcon, ChevronIcon$1 as ChevronIcon, Cluster, CollapsibleSection$1 as CollapsibleSection, CountryDropdown, Cover, CustomerSearchIcon, DefaultPageTemplate, Detail$1 as Detail, DisplayBox$1 as DisplayBox, DisplayCard, Dropdown$1 as Dropdown, DuplicateIcon, EditNameForm, EditableList, EditableTable, EmailForm, EmptyCartIcon$1 as EmptyCartIcon, ErroredIcon, ExternalLink, FailedIcon, ForgotPasswordForm, ForgotPasswordIcon$1 as ForgotPasswordIcon, FormContainer$1 as FormContainer, FormFooterPanel$1 as FormFooterPanel, FormInput$1 as FormInput, FormInputColumn, FormInputRow, FormSelect$1 as FormSelect, FormattedAddress$1 as FormattedAddress, FormattedCreditCard$1 as FormattedCreditCard, Frame, GenericCard, GenericCardLarge, GoToEmailIcon$1 as GoToEmailIcon, Grid, HamburgerButton, Heading$1 as Heading, HighlightTabRow$1 as HighlightTabRow, IconAdd, IconQuitLarge, Imposter, InternalLink, InternalUserInfoForm, Jumbo$1 as Jumbo, LabeledAmount$1 as LabeledAmount, LineItem$1 as LineItem, Loading, LoginForm, Modal$1 as Modal, Module$1 as Module, Motion, NavFooter, NavHeader, NavMenuDesktop$1 as NavMenuDesktop, NavMenuMobile$1 as NavMenuMobile, NoCustomerResultsIcon, NoPaymentResultsIcon, NotFoundIcon, Obligation, iconsMap as ObligationIcons, Pagination, Paragraph$1 as Paragraph, PartialAmountForm, PasswordRequirements, PaymentButtonBar, PaymentDetails$1 as PaymentDetails, PaymentFormACH, PaymentFormCard$1 as PaymentFormCard, PaymentIcon, PaymentMethodAddIcon$1 as PaymentMethodAddIcon, PaymentMethodIcon$1 as PaymentMethodIcon, PaymentSearchIcon, PaymentsIconSmall$1 as PaymentsIconSmall, PendingIcon, PeriscopeFailedIcon, PhoneForm, Placeholder$1 as Placeholder, ProcessingFee$1 as ProcessingFee, ProfileIcon$1 as ProfileIcon, ProfileIconSmall$1 as ProfileIconSmall, PropertiesAddIcon$1 as PropertiesAddIcon, PropertiesIconSmall$1 as PropertiesIconSmall, RadioButton$2 as RadioButton, RadioSection$1 as RadioSection, Reel, RefundIcon, RegistrationForm, RejectedIcon, RejectedVelocityIcon, ResetConfirmationForm$1 as ResetConfirmationForm, ResetPasswordForm, ResetPasswordIcon, ResetPasswordSuccess, RoutingNumberImage, SearchIcon, SearchableSelect$1 as SearchableSelect, SettingsIconSmall$1 as SettingsIconSmall, ShoppingCartIcon, Sidebar, SidebarSingleContent$1 as SidebarSingleContent, SidebarStackContent$1 as SidebarStackContent, SolidDivider$1 as SolidDivider, Spinner$2 as Spinner, Stack, FormStateDropdown as StateProvinceDropdown, StatusUnknownIcon, SuccessfulIcon, Switcher, TabSidebar$1 as TabSidebar, TableListItem, Tabs$1 as Tabs, TermsAndConditions, TermsAndConditionsModal$1 as TermsAndConditionsModal, Text$1 as Text, Timeout$1 as Timeout, TimeoutImage, Title$1 as Title, ToggleSwitch$1 as ToggleSwitch, TrashIcon$1 as TrashIcon, TypeaheadInput, VerifiedEmailIcon$1 as VerifiedEmailIcon, VoidedIcon, WalletIcon$1 as WalletIcon, WarningIconXS, WelcomeModule$1 as WelcomeModule, WorkflowTile, cardRegistry, index$5 as constants, createPartialAmountFormState, index$6 as util, withWindowSize };
 //# sourceMappingURL=index.esm.js.map