@alma/widgets 2.8.0 → 2.8.3

package/dist/raw/widgets.umd.js

@@ -34,13 +34,21 @@
   };
 
   var ceil = Math.ceil;
-  var floor = Math.floor; // `ToIntegerOrInfinity` abstract operation
+  var floor = Math.floor; // `Math.trunc` method
+  // https://tc39.es/ecma262/#sec-math.trunc
+  // eslint-disable-next-line es-x/no-math-trunc -- safe
+
+  var mathTrunc = Math.trunc || function trunc(x) {
+    var n = +x;
+    return (n > 0 ? floor : ceil)(n);
+  };
+
   // https://tc39.es/ecma262/#sec-tointegerorinfinity
 
   var toIntegerOrInfinity = function (argument) {
-    var number = +argument; // eslint-disable-next-line no-self-compare -- safe
+    var number = +argument; // eslint-disable-next-line no-self-compare -- NaN check
 
-    return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);
+    return number !== number || number === 0 ? 0 : mathTrunc(number);
   };
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -77,7 +85,7 @@
 
   var defineProperty = Object.defineProperty;
 
-  var setGlobal = function (key, value) {
+  var defineGlobalProperty = function (key, value) {
     try {
       defineProperty(global_1, key, {
         value: value,
@@ -92,34 +100,34 @@
   };
 
   var SHARED = '__core-js_shared__';
-  var store = global_1[SHARED] || setGlobal(SHARED, {});
+  var store = global_1[SHARED] || defineGlobalProperty(SHARED, {});
   var sharedStore = store;
 
   var shared = createCommonjsModule(function (module) {
     (module.exports = function (key, value) {
       return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});
     })('versions', []).push({
-      version: '3.22.1',
+      version: '3.22.8',
       mode:  'global',
       copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
-      license: 'https://github.com/zloirock/core-js/blob/v3.22.1/LICENSE',
+      license: 'https://github.com/zloirock/core-js/blob/v3.22.8/LICENSE',
       source: 'https://github.com/zloirock/core-js'
     });
   });
 
-  var TypeError$1 = global_1.TypeError; // `RequireObjectCoercible` abstract operation
+  var $TypeError = TypeError; // `RequireObjectCoercible` abstract operation
   // https://tc39.es/ecma262/#sec-requireobjectcoercible
 
   var requireObjectCoercible = function (it) {
-    if (it == undefined) throw TypeError$1("Can't call method on " + it);
+    if (it == undefined) throw $TypeError("Can't call method on " + it);
     return it;
   };
 
-  var Object$1 = global_1.Object; // `ToObject` abstract operation
+  var $Object = Object; // `ToObject` abstract operation
   // https://tc39.es/ecma262/#sec-toobject
 
   var toObject = function (argument) {
-    return Object$1(requireObjectCoercible(argument));
+    return $Object(requireObjectCoercible(argument));
   };
 
   var hasOwnProperty = functionUncurryThis({}.hasOwnProperty); // `HasOwnProperty` abstract operation
@@ -229,7 +237,7 @@
   };
 
   var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag');
-  var Object$2 = global_1.Object; // ES3 wrong here
+  var $Object$1 = Object; // ES3 wrong here
 
   var CORRECT_ARGUMENTS = classofRaw(function () {
     return arguments;
@@ -247,16 +255,16 @@
   var classof = toStringTagSupport ? classofRaw : function (it) {
     var O, tag, result;
     return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case
-    : typeof (tag = tryGet(O = Object$2(it), TO_STRING_TAG$1)) == 'string' ? tag // builtinTag case
+    : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag // builtinTag case
     : CORRECT_ARGUMENTS ? classofRaw(O) // ES3 arguments fallback
     : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
   };
 
-  var String$1 = global_1.String;
+  var $String = String;
 
   var toString_1 = function (argument) {
     if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
-    return String$1(argument);
+    return $String(argument);
   };
 
   var charAt = functionUncurryThis(''.charAt);
@@ -339,12 +347,12 @@
     }).prototype != 42;
   });
 
-  var String$2 = global_1.String;
-  var TypeError$2 = global_1.TypeError; // `Assert: Type(argument) is Object`
+  var $String$1 = String;
+  var $TypeError$1 = TypeError; // `Assert: Type(argument) is Object`
 
   var anObject = function (argument) {
     if (isObject(argument)) return argument;
-    throw TypeError$2(String$2(argument) + ' is not an object');
+    throw $TypeError$1($String$1(argument) + ' is not an object');
   };
 
   var call$1 = Function.prototype.call;
@@ -354,29 +362,29 @@
 
   var objectIsPrototypeOf = functionUncurryThis({}.isPrototypeOf);
 
-  var Object$3 = global_1.Object;
+  var $Object$2 = Object;
   var isSymbol = useSymbolAsUid ? function (it) {
     return typeof it == 'symbol';
   } : function (it) {
     var $Symbol = getBuiltIn('Symbol');
-    return isCallable($Symbol) && objectIsPrototypeOf($Symbol.prototype, Object$3(it));
+    return isCallable($Symbol) && objectIsPrototypeOf($Symbol.prototype, $Object$2(it));
   };
 
-  var String$3 = global_1.String;
+  var $String$2 = String;
 
   var tryToString = function (argument) {
     try {
-      return String$3(argument);
+      return $String$2(argument);
     } catch (error) {
       return 'Object';
     }
   };
 
-  var TypeError$3 = global_1.TypeError; // `Assert: IsCallable(argument) is true`
+  var $TypeError$2 = TypeError; // `Assert: IsCallable(argument) is true`
 
   var aCallable = function (argument) {
     if (isCallable(argument)) return argument;
-    throw TypeError$3(tryToString(argument) + ' is not a function');
+    throw $TypeError$2(tryToString(argument) + ' is not a function');
   };
 
   // https://tc39.es/ecma262/#sec-getmethod
@@ -386,7 +394,7 @@
     return func == null ? undefined : aCallable(func);
   };
 
-  var TypeError$4 = global_1.TypeError; // `OrdinaryToPrimitive` abstract operation
+  var $TypeError$3 = TypeError; // `OrdinaryToPrimitive` abstract operation
   // https://tc39.es/ecma262/#sec-ordinarytoprimitive
 
   var ordinaryToPrimitive = function (input, pref) {
@@ -394,10 +402,10 @@
     if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = functionCall(fn, input))) return val;
     if (isCallable(fn = input.valueOf) && !isObject(val = functionCall(fn, input))) return val;
     if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = functionCall(fn, input))) return val;
-    throw TypeError$4("Can't convert object to primitive value");
+    throw $TypeError$3("Can't convert object to primitive value");
   };
 
-  var TypeError$5 = global_1.TypeError;
+  var $TypeError$4 = TypeError;
   var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); // `ToPrimitive` abstract operation
   // https://tc39.es/ecma262/#sec-toprimitive
 
@@ -410,7 +418,7 @@
       if (pref === undefined) pref = 'default';
       result = functionCall(exoticToPrim, input, pref);
       if (!isObject(result) || isSymbol(result)) return result;
-      throw TypeError$5("Can't convert object to primitive value");
+      throw $TypeError$4("Can't convert object to primitive value");
     }
 
     if (pref === undefined) pref = 'number';
@@ -424,7 +432,7 @@
     return isSymbol(key) ? key : key + '';
   };
 
-  var TypeError$6 = global_1.TypeError; // eslint-disable-next-line es-x/no-object-defineproperty -- safe
+  var $TypeError$5 = TypeError; // eslint-disable-next-line es-x/no-object-defineproperty -- safe
 
   var $defineProperty = Object.defineProperty; // eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
 
@@ -462,7 +470,7 @@
     } catch (error) {
       /* empty */
     }
-    if ('get' in Attributes || 'set' in Attributes) throw TypeError$6('Accessors not supported');
+    if ('get' in Attributes || 'set' in Attributes) throw $TypeError$5('Accessors not supported');
     if ('value' in Attributes) O[P] = Attributes.value;
     return O;
   };
@@ -495,7 +503,7 @@
   var hiddenKeys = {};
 
   var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
-  var TypeError$7 = global_1.TypeError;
+  var TypeError$1 = global_1.TypeError;
   var WeakMap$2 = global_1.WeakMap;
   var set, get, has;
 
@@ -508,7 +516,7 @@
       var state;
 
       if (!isObject(it) || (state = get(it)).type !== TYPE) {
-        throw TypeError$7('Incompatible receiver, ' + TYPE + ' required');
+        throw TypeError$1('Incompatible receiver, ' + TYPE + ' required');
       }
 
       return state;
@@ -522,7 +530,7 @@
     var wmset = functionUncurryThis(store$1.set);
 
     set = function (it, metadata) {
-      if (wmhas(store$1, it)) throw new TypeError$7(OBJECT_ALREADY_INITIALIZED);
+      if (wmhas(store$1, it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
       metadata.facade = it;
       wmset(store$1, it, metadata);
       return metadata;
@@ -540,7 +548,7 @@
     hiddenKeys[STATE] = true;
 
     set = function (it, metadata) {
-      if (hasOwnProperty_1(it, STATE)) throw new TypeError$7(OBJECT_ALREADY_INITIALIZED);
+      if (hasOwnProperty_1(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
       metadata.facade = it;
       createNonEnumerableProperty(it, STATE, metadata);
       return metadata;
@@ -580,16 +588,16 @@
     f: f$1
   };
 
-  var Object$4 = global_1.Object;
+  var $Object$3 = Object;
   var split = functionUncurryThis(''.split); // fallback for non-array-like ES3 and non-enumerable old V8 strings
 
   var indexedObject = fails(function () {
     // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
     // eslint-disable-next-line no-prototype-builtins -- safe
-    return !Object$4('z').propertyIsEnumerable(0);
+    return !$Object$3('z').propertyIsEnumerable(0);
   }) ? function (it) {
-    return classofRaw(it) == 'String' ? split(it, '') : Object$4(it);
-  } : Object$4;
+    return classofRaw(it) == 'String' ? split(it, '') : $Object$3(it);
+  } : $Object$3;
 
   var toIndexedObject = function (it) {
     return indexedObject(requireObjectCoercible(it));
@@ -628,49 +636,84 @@
     CONFIGURABLE: CONFIGURABLE$1
   };
 
-  var redefine = createCommonjsModule(function (module) {
+  var makeBuiltIn_1 = createCommonjsModule(function (module) {
     var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
-    var getInternalState = internalState.get;
     var enforceInternalState = internalState.enforce;
+    var getInternalState = internalState.get; // eslint-disable-next-line es-x/no-object-defineproperty -- safe
+
+    var defineProperty = Object.defineProperty;
+    var CONFIGURABLE_LENGTH = descriptors && !fails(function () {
+      return defineProperty(function () {
+        /* empty */
+      }, 'length', {
+        value: 8
+      }).length !== 8;
+    });
     var TEMPLATE = String(String).split('String');
-    (module.exports = function (O, key, value, options) {
-      var unsafe = options ? !!options.unsafe : false;
-      var simple = options ? !!options.enumerable : false;
-      var noTargetGet = options ? !!options.noTargetGet : false;
-      var name = options && options.name !== undefined ? options.name : key;
-      var state;
 
-      if (isCallable(value)) {
-        if (String(name).slice(0, 7) === 'Symbol(') {
-          name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
-        }
+    var makeBuiltIn = module.exports = function (value, name, options) {
+      if (String(name).slice(0, 7) === 'Symbol(') {
+        name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
+      }
 
-        if (!hasOwnProperty_1(value, 'name') || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
-          createNonEnumerableProperty(value, 'name', name);
-        }
+      if (options && options.getter) name = 'get ' + name;
+      if (options && options.setter) name = 'set ' + name;
 
-        state = enforceInternalState(value);
+      if (!hasOwnProperty_1(value, 'name') || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
+        defineProperty(value, 'name', {
+          value: name,
+          configurable: true
+        });
+      }
 
-        if (!state.source) {
-          state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
-        }
+      if (CONFIGURABLE_LENGTH && options && hasOwnProperty_1(options, 'arity') && value.length !== options.arity) {
+        defineProperty(value, 'length', {
+          value: options.arity
+        });
       }
 
-      if (O === global_1) {
-        if (simple) O[key] = value;else setGlobal(key, value);
-        return;
-      } else if (!unsafe) {
-        delete O[key];
-      } else if (!noTargetGet && O[key]) {
-        simple = true;
+      try {
+        if (options && hasOwnProperty_1(options, 'constructor') && options.constructor) {
+          if (descriptors) defineProperty(value, 'prototype', {
+            writable: false
+          }); // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
+        } else if (value.prototype) value.prototype = undefined;
+      } catch (error) {
+        /* empty */
+      }
+
+      var state = enforceInternalState(value);
+
+      if (!hasOwnProperty_1(state, 'source')) {
+        state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
       }
 
-      if (simple) O[key] = value;else createNonEnumerableProperty(O, key, value); // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
-    })(Function.prototype, 'toString', function toString() {
+      return value;
+    }; // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+    // eslint-disable-next-line no-extend-native -- required
+
+
+    Function.prototype.toString = makeBuiltIn(function toString() {
       return isCallable(this) && getInternalState(this).source || inspectSource(this);
-    });
+    }, 'toString');
   });
 
+  var defineBuiltIn = function (O, key, value, options) {
+    if (!options) options = {};
+    var simple = options.enumerable;
+    var name = options.name !== undefined ? options.name : key;
+    if (isCallable(value)) makeBuiltIn_1(value, name, options);
+
+    if (options.global) {
+      if (simple) O[key] = value;else defineGlobalProperty(key, value);
+    } else {
+      if (!options.unsafe) delete O[key];else if (O[key]) simple = true;
+      if (simple) O[key] = value;else createNonEnumerableProperty(O, key, value);
+    }
+
+    return O;
+  };
+
   var max = Math.max;
   var min = Math.min; // Helper for a popular repeating case of the spec:
   // Let integer be ? ToInteger(index).
@@ -802,19 +845,19 @@
 
   var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
   /*
-    options.target      - name of the target object
-    options.global      - target is the global object
-    options.stat        - export as static methods of target
-    options.proto       - export as prototype methods of target
-    options.real        - real prototype method for the `pure` version
-    options.forced      - export even if the native feature is available
-    options.bind        - bind methods to the target, required for the `pure` version
-    options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
-    options.unsafe      - use the simple assignment of property instead of delete + defineProperty
-    options.sham        - add a flag to not completely full polyfills
-    options.enumerable  - export as enumerable property
-    options.noTargetGet - prevent calling a getter on target
-    options.name        - the .name of the function if it does not match the key
+    options.target         - name of the target object
+    options.global         - target is the global object
+    options.stat           - export as static methods of target
+    options.proto          - export as prototype methods of target
+    options.real           - real prototype method for the `pure` version
+    options.forced         - export even if the native feature is available
+    options.bind           - bind methods to the target, required for the `pure` version
+    options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
+    options.unsafe         - use the simple assignment of property instead of delete + defineProperty
+    options.sham           - add a flag to not completely full polyfills
+    options.enumerable     - export as enumerable property
+    options.dontCallGetSet - prevent calling a getter on target
+    options.name           - the .name of the function if it does not match the key
   */
 
   var _export = function (options, source) {
@@ -826,7 +869,7 @@
     if (GLOBAL) {
       target = global_1;
     } else if (STATIC) {
-      target = global_1[TARGET] || setGlobal(TARGET, {});
+      target = global_1[TARGET] || defineGlobalProperty(TARGET, {});
     } else {
       target = (global_1[TARGET] || {}).prototype;
     }
@@ -834,7 +877,7 @@
     if (target) for (key in source) {
       sourceProperty = source[key];
 
-      if (options.noTargetGet) {
+      if (options.dontCallGetSet) {
         descriptor = getOwnPropertyDescriptor$1(target, key);
         targetProperty = descriptor && descriptor.value;
       } else targetProperty = target[key];
@@ -849,10 +892,9 @@
 
       if (options.sham || targetProperty && targetProperty.sham) {
         createNonEnumerableProperty(sourceProperty, 'sham', true);
-      } // extend global
-
+      }
 
-      redefine(target, key, sourceProperty, options);
+      defineBuiltIn(target, key, sourceProperty, options);
     }
   };
 
@@ -980,11 +1022,12 @@
   });
 
   var IE_PROTO$1 = sharedKey('IE_PROTO');
-  var Object$5 = global_1.Object;
-  var ObjectPrototype = Object$5.prototype; // `Object.getPrototypeOf` method
+  var $Object$4 = Object;
+  var ObjectPrototype = $Object$4.prototype; // `Object.getPrototypeOf` method
   // https://tc39.es/ecma262/#sec-object.getprototypeof
+  // eslint-disable-next-line es-x/no-object-getprototypeof -- safe
 
-  var objectGetPrototypeOf = correctPrototypeGetter ? Object$5.getPrototypeOf : function (O) {
+  var objectGetPrototypeOf = correctPrototypeGetter ? $Object$4.getPrototypeOf : function (O) {
     var object = toObject(O);
     if (hasOwnProperty_1(object, IE_PROTO$1)) return object[IE_PROTO$1];
     var constructor = object.constructor;
@@ -993,7 +1036,7 @@
       return constructor.prototype;
     }
 
-    return object instanceof Object$5 ? ObjectPrototype : null;
+    return object instanceof $Object$4 ? ObjectPrototype : null;
   };
 
   var ITERATOR = wellKnownSymbol('iterator');
@@ -1021,7 +1064,7 @@
   // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
 
   if (!isCallable(IteratorPrototype[ITERATOR])) {
-    redefine(IteratorPrototype, ITERATOR, function () {
+    defineBuiltIn(IteratorPrototype, ITERATOR, function () {
       return this;
     });
   }
@@ -1063,12 +1106,12 @@
     return IteratorConstructor;
   };
 
-  var String$4 = global_1.String;
-  var TypeError$8 = global_1.TypeError;
+  var $String$3 = String;
+  var $TypeError$6 = TypeError;
 
   var aPossiblePrototype = function (argument) {
     if (typeof argument == 'object' || isCallable(argument)) return argument;
-    throw TypeError$8("Can't set " + String$4(argument) + ' as a prototype');
+    throw $TypeError$6("Can't set " + $String$3(argument) + ' as a prototype');
   };
 
   /* eslint-disable no-proto -- safe */
@@ -1157,7 +1200,7 @@
           if (objectSetPrototypeOf) {
             objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2);
           } else if (!isCallable(CurrentIteratorPrototype[ITERATOR$1])) {
-            redefine(CurrentIteratorPrototype, ITERATOR$1, returnThis$1);
+            defineBuiltIn(CurrentIteratorPrototype, ITERATOR$1, returnThis$1);
           }
         } // Set @@toStringTag to native iterators
 
@@ -1188,7 +1231,7 @@
       };
       if (FORCED) for (KEY in methods) {
         if (BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
-          redefine(IterablePrototype, KEY, methods[KEY]);
+          defineBuiltIn(IterablePrototype, KEY, methods[KEY]);
         }
       } else _export({
         target: NAME,
@@ -1199,7 +1242,7 @@
 
 
     if ( IterablePrototype[ITERATOR$1] !== defaultIterator) {
-      redefine(IterablePrototype, ITERATOR$1, defaultIterator, {
+      defineBuiltIn(IterablePrototype, ITERATOR$1, defaultIterator, {
         name: DEFAULT
       });
     }
@@ -1350,15 +1393,15 @@
     if (it != undefined) return getMethod(it, ITERATOR$3) || getMethod(it, '@@iterator') || iterators[classof(it)];
   };
 
-  var TypeError$9 = global_1.TypeError;
+  var $TypeError$7 = TypeError;
 
   var getIterator = function (argument, usingIterator) {
     var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
     if (aCallable(iteratorMethod)) return anObject(functionCall(iteratorMethod, argument));
-    throw TypeError$9(tryToString(argument) + ' is not iterable');
+    throw $TypeError$7(tryToString(argument) + ' is not iterable');
   };
 
-  var Array$1 = global_1.Array; // `Array.from` method implementation
+  var $Array = Array; // `Array.from` method implementation
   // https://tc39.es/ecma262/#sec-array.from
 
   var arrayFrom = function from(arrayLike
@@ -1374,7 +1417,7 @@
     var index = 0;
     var length, result, step, iterator, next, value; // if the target is not iterable or it's an array with the default iterator - use a simple case
 
-    if (iteratorMethod && !(this == Array$1 && isArrayIteratorMethod(iteratorMethod))) {
+    if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {
       iterator = getIterator(O, iteratorMethod);
       next = iterator.next;
       result = IS_CONSTRUCTOR ? new this() : [];
@@ -1385,7 +1428,7 @@
       }
     } else {
       length = lengthOfArrayLike(O);
-      result = IS_CONSTRUCTOR ? new this(length) : Array$1(length);
+      result = IS_CONSTRUCTOR ? new this(length) : $Array(length);
 
       for (; length > index; index++) {
         value = mapping ? mapfn(O[index], index) : O[index];
@@ -2324,7 +2367,7 @@
     }
   });
 
-  /*! *****************************************************************************
+  /******************************************************************************
   Copyright (c) Microsoft Corporation.
 
   Permission to use, copy, modify, and/or distribute this software for any
@@ -3297,6 +3340,360 @@
     return result;
   }
 
+  // @generated from time-data-gen.ts
+  // prettier-ignore  
+  var timeData = {
+    "AX": ["H"],
+    "BQ": ["H"],
+    "CP": ["H"],
+    "CZ": ["H"],
+    "DK": ["H"],
+    "FI": ["H"],
+    "ID": ["H"],
+    "IS": ["H"],
+    "ML": ["H"],
+    "NE": ["H"],
+    "RU": ["H"],
+    "SE": ["H"],
+    "SJ": ["H"],
+    "SK": ["H"],
+    "AS": ["h", "H"],
+    "BT": ["h", "H"],
+    "DJ": ["h", "H"],
+    "ER": ["h", "H"],
+    "GH": ["h", "H"],
+    "IN": ["h", "H"],
+    "LS": ["h", "H"],
+    "PG": ["h", "H"],
+    "PW": ["h", "H"],
+    "SO": ["h", "H"],
+    "TO": ["h", "H"],
+    "VU": ["h", "H"],
+    "WS": ["h", "H"],
+    "001": ["H", "h"],
+    "AL": ["h", "H", "hB"],
+    "TD": ["h", "H", "hB"],
+    "ca-ES": ["H", "h", "hB"],
+    "CF": ["H", "h", "hB"],
+    "CM": ["H", "h", "hB"],
+    "fr-CA": ["H", "h", "hB"],
+    "gl-ES": ["H", "h", "hB"],
+    "it-CH": ["H", "h", "hB"],
+    "it-IT": ["H", "h", "hB"],
+    "LU": ["H", "h", "hB"],
+    "NP": ["H", "h", "hB"],
+    "PF": ["H", "h", "hB"],
+    "SC": ["H", "h", "hB"],
+    "SM": ["H", "h", "hB"],
+    "SN": ["H", "h", "hB"],
+    "TF": ["H", "h", "hB"],
+    "VA": ["H", "h", "hB"],
+    "CY": ["h", "H", "hb", "hB"],
+    "GR": ["h", "H", "hb", "hB"],
+    "CO": ["h", "H", "hB", "hb"],
+    "DO": ["h", "H", "hB", "hb"],
+    "KP": ["h", "H", "hB", "hb"],
+    "KR": ["h", "H", "hB", "hb"],
+    "NA": ["h", "H", "hB", "hb"],
+    "PA": ["h", "H", "hB", "hb"],
+    "PR": ["h", "H", "hB", "hb"],
+    "VE": ["h", "H", "hB", "hb"],
+    "AC": ["H", "h", "hb", "hB"],
+    "AI": ["H", "h", "hb", "hB"],
+    "BW": ["H", "h", "hb", "hB"],
+    "BZ": ["H", "h", "hb", "hB"],
+    "CC": ["H", "h", "hb", "hB"],
+    "CK": ["H", "h", "hb", "hB"],
+    "CX": ["H", "h", "hb", "hB"],
+    "DG": ["H", "h", "hb", "hB"],
+    "FK": ["H", "h", "hb", "hB"],
+    "GB": ["H", "h", "hb", "hB"],
+    "GG": ["H", "h", "hb", "hB"],
+    "GI": ["H", "h", "hb", "hB"],
+    "IE": ["H", "h", "hb", "hB"],
+    "IM": ["H", "h", "hb", "hB"],
+    "IO": ["H", "h", "hb", "hB"],
+    "JE": ["H", "h", "hb", "hB"],
+    "LT": ["H", "h", "hb", "hB"],
+    "MK": ["H", "h", "hb", "hB"],
+    "MN": ["H", "h", "hb", "hB"],
+    "MS": ["H", "h", "hb", "hB"],
+    "NF": ["H", "h", "hb", "hB"],
+    "NG": ["H", "h", "hb", "hB"],
+    "NR": ["H", "h", "hb", "hB"],
+    "NU": ["H", "h", "hb", "hB"],
+    "PN": ["H", "h", "hb", "hB"],
+    "SH": ["H", "h", "hb", "hB"],
+    "SX": ["H", "h", "hb", "hB"],
+    "TA": ["H", "h", "hb", "hB"],
+    "ZA": ["H", "h", "hb", "hB"],
+    "af-ZA": ["H", "h", "hB", "hb"],
+    "AR": ["H", "h", "hB", "hb"],
+    "CL": ["H", "h", "hB", "hb"],
+    "CR": ["H", "h", "hB", "hb"],
+    "CU": ["H", "h", "hB", "hb"],
+    "EA": ["H", "h", "hB", "hb"],
+    "es-BO": ["H", "h", "hB", "hb"],
+    "es-BR": ["H", "h", "hB", "hb"],
+    "es-EC": ["H", "h", "hB", "hb"],
+    "es-ES": ["H", "h", "hB", "hb"],
+    "es-GQ": ["H", "h", "hB", "hb"],
+    "es-PE": ["H", "h", "hB", "hb"],
+    "GT": ["H", "h", "hB", "hb"],
+    "HN": ["H", "h", "hB", "hb"],
+    "IC": ["H", "h", "hB", "hb"],
+    "KG": ["H", "h", "hB", "hb"],
+    "KM": ["H", "h", "hB", "hb"],
+    "LK": ["H", "h", "hB", "hb"],
+    "MA": ["H", "h", "hB", "hb"],
+    "MX": ["H", "h", "hB", "hb"],
+    "NI": ["H", "h", "hB", "hb"],
+    "PY": ["H", "h", "hB", "hb"],
+    "SV": ["H", "h", "hB", "hb"],
+    "UY": ["H", "h", "hB", "hb"],
+    "JP": ["H", "h", "K"],
+    "AD": ["H", "hB"],
+    "AM": ["H", "hB"],
+    "AO": ["H", "hB"],
+    "AT": ["H", "hB"],
+    "AW": ["H", "hB"],
+    "BE": ["H", "hB"],
+    "BF": ["H", "hB"],
+    "BJ": ["H", "hB"],
+    "BL": ["H", "hB"],
+    "BR": ["H", "hB"],
+    "CG": ["H", "hB"],
+    "CI": ["H", "hB"],
+    "CV": ["H", "hB"],
+    "DE": ["H", "hB"],
+    "EE": ["H", "hB"],
+    "FR": ["H", "hB"],
+    "GA": ["H", "hB"],
+    "GF": ["H", "hB"],
+    "GN": ["H", "hB"],
+    "GP": ["H", "hB"],
+    "GW": ["H", "hB"],
+    "HR": ["H", "hB"],
+    "IL": ["H", "hB"],
+    "IT": ["H", "hB"],
+    "KZ": ["H", "hB"],
+    "MC": ["H", "hB"],
+    "MD": ["H", "hB"],
+    "MF": ["H", "hB"],
+    "MQ": ["H", "hB"],
+    "MZ": ["H", "hB"],
+    "NC": ["H", "hB"],
+    "NL": ["H", "hB"],
+    "PM": ["H", "hB"],
+    "PT": ["H", "hB"],
+    "RE": ["H", "hB"],
+    "RO": ["H", "hB"],
+    "SI": ["H", "hB"],
+    "SR": ["H", "hB"],
+    "ST": ["H", "hB"],
+    "TG": ["H", "hB"],
+    "TR": ["H", "hB"],
+    "WF": ["H", "hB"],
+    "YT": ["H", "hB"],
+    "BD": ["h", "hB", "H"],
+    "PK": ["h", "hB", "H"],
+    "AZ": ["H", "hB", "h"],
+    "BA": ["H", "hB", "h"],
+    "BG": ["H", "hB", "h"],
+    "CH": ["H", "hB", "h"],
+    "GE": ["H", "hB", "h"],
+    "LI": ["H", "hB", "h"],
+    "ME": ["H", "hB", "h"],
+    "RS": ["H", "hB", "h"],
+    "UA": ["H", "hB", "h"],
+    "UZ": ["H", "hB", "h"],
+    "XK": ["H", "hB", "h"],
+    "AG": ["h", "hb", "H", "hB"],
+    "AU": ["h", "hb", "H", "hB"],
+    "BB": ["h", "hb", "H", "hB"],
+    "BM": ["h", "hb", "H", "hB"],
+    "BS": ["h", "hb", "H", "hB"],
+    "CA": ["h", "hb", "H", "hB"],
+    "DM": ["h", "hb", "H", "hB"],
+    "en-001": ["h", "hb", "H", "hB"],
+    "FJ": ["h", "hb", "H", "hB"],
+    "FM": ["h", "hb", "H", "hB"],
+    "GD": ["h", "hb", "H", "hB"],
+    "GM": ["h", "hb", "H", "hB"],
+    "GU": ["h", "hb", "H", "hB"],
+    "GY": ["h", "hb", "H", "hB"],
+    "JM": ["h", "hb", "H", "hB"],
+    "KI": ["h", "hb", "H", "hB"],
+    "KN": ["h", "hb", "H", "hB"],
+    "KY": ["h", "hb", "H", "hB"],
+    "LC": ["h", "hb", "H", "hB"],
+    "LR": ["h", "hb", "H", "hB"],
+    "MH": ["h", "hb", "H", "hB"],
+    "MP": ["h", "hb", "H", "hB"],
+    "MW": ["h", "hb", "H", "hB"],
+    "NZ": ["h", "hb", "H", "hB"],
+    "SB": ["h", "hb", "H", "hB"],
+    "SG": ["h", "hb", "H", "hB"],
+    "SL": ["h", "hb", "H", "hB"],
+    "SS": ["h", "hb", "H", "hB"],
+    "SZ": ["h", "hb", "H", "hB"],
+    "TC": ["h", "hb", "H", "hB"],
+    "TT": ["h", "hb", "H", "hB"],
+    "UM": ["h", "hb", "H", "hB"],
+    "US": ["h", "hb", "H", "hB"],
+    "VC": ["h", "hb", "H", "hB"],
+    "VG": ["h", "hb", "H", "hB"],
+    "VI": ["h", "hb", "H", "hB"],
+    "ZM": ["h", "hb", "H", "hB"],
+    "BO": ["H", "hB", "h", "hb"],
+    "EC": ["H", "hB", "h", "hb"],
+    "ES": ["H", "hB", "h", "hb"],
+    "GQ": ["H", "hB", "h", "hb"],
+    "PE": ["H", "hB", "h", "hb"],
+    "AE": ["h", "hB", "hb", "H"],
+    "ar-001": ["h", "hB", "hb", "H"],
+    "BH": ["h", "hB", "hb", "H"],
+    "DZ": ["h", "hB", "hb", "H"],
+    "EG": ["h", "hB", "hb", "H"],
+    "EH": ["h", "hB", "hb", "H"],
+    "HK": ["h", "hB", "hb", "H"],
+    "IQ": ["h", "hB", "hb", "H"],
+    "JO": ["h", "hB", "hb", "H"],
+    "KW": ["h", "hB", "hb", "H"],
+    "LB": ["h", "hB", "hb", "H"],
+    "LY": ["h", "hB", "hb", "H"],
+    "MO": ["h", "hB", "hb", "H"],
+    "MR": ["h", "hB", "hb", "H"],
+    "OM": ["h", "hB", "hb", "H"],
+    "PH": ["h", "hB", "hb", "H"],
+    "PS": ["h", "hB", "hb", "H"],
+    "QA": ["h", "hB", "hb", "H"],
+    "SA": ["h", "hB", "hb", "H"],
+    "SD": ["h", "hB", "hb", "H"],
+    "SY": ["h", "hB", "hb", "H"],
+    "TN": ["h", "hB", "hb", "H"],
+    "YE": ["h", "hB", "hb", "H"],
+    "AF": ["H", "hb", "hB", "h"],
+    "LA": ["H", "hb", "hB", "h"],
+    "CN": ["H", "hB", "hb", "h"],
+    "LV": ["H", "hB", "hb", "h"],
+    "TL": ["H", "hB", "hb", "h"],
+    "zu-ZA": ["H", "hB", "hb", "h"],
+    "CD": ["hB", "H"],
+    "IR": ["hB", "H"],
+    "hi-IN": ["hB", "h", "H"],
+    "kn-IN": ["hB", "h", "H"],
+    "ml-IN": ["hB", "h", "H"],
+    "te-IN": ["hB", "h", "H"],
+    "KH": ["hB", "h", "H", "hb"],
+    "ta-IN": ["hB", "h", "hb", "H"],
+    "BN": ["hb", "hB", "h", "H"],
+    "MY": ["hb", "hB", "h", "H"],
+    "ET": ["hB", "hb", "h", "H"],
+    "gu-IN": ["hB", "hb", "h", "H"],
+    "mr-IN": ["hB", "hb", "h", "H"],
+    "pa-IN": ["hB", "hb", "h", "H"],
+    "TW": ["hB", "hb", "h", "H"],
+    "KE": ["hB", "hb", "H", "h"],
+    "MM": ["hB", "hb", "H", "h"],
+    "TZ": ["hB", "hb", "H", "h"],
+    "UG": ["hB", "hb", "H", "h"]
+  };
+
+  /**
+   * Returns the best matching date time pattern if a date time skeleton
+   * pattern is provided with a locale. Follows the Unicode specification:
+   * https://www.unicode.org/reports/tr35/tr35-dates.html#table-mapping-requested-time-skeletons-to-patterns
+   * @param skeleton date time skeleton pattern that possibly includes j, J or C
+   * @param locale
+   */
+
+  function getBestPattern(skeleton, locale) {
+    var skeletonCopy = '';
+
+    for (var patternPos = 0; patternPos < skeleton.length; patternPos++) {
+      var patternChar = skeleton.charAt(patternPos);
+
+      if (patternChar === 'j') {
+        var extraLength = 0;
+
+        while (patternPos + 1 < skeleton.length && skeleton.charAt(patternPos + 1) === patternChar) {
+          extraLength++;
+          patternPos++;
+        }
+
+        var hourLen = 1 + (extraLength & 1);
+        var dayPeriodLen = extraLength < 2 ? 1 : 3 + (extraLength >> 1);
+        var dayPeriodChar = 'a';
+        var hourChar = getDefaultHourSymbolFromLocale(locale);
+
+        if (hourChar == 'H' || hourChar == 'k') {
+          dayPeriodLen = 0;
+        }
+
+        while (dayPeriodLen-- > 0) {
+          skeletonCopy += dayPeriodChar;
+        }
+
+        while (hourLen-- > 0) {
+          skeletonCopy = hourChar + skeletonCopy;
+        }
+      } else if (patternChar === 'J') {
+        skeletonCopy += 'H';
+      } else {
+        skeletonCopy += patternChar;
+      }
+    }
+
+    return skeletonCopy;
+  }
+  /**
+   * Maps the [hour cycle type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle)
+   * of the given `locale` to the corresponding time pattern.
+   * @param locale
+   */
+
+  function getDefaultHourSymbolFromLocale(locale) {
+    var hourCycle = locale.hourCycle;
+
+    if (hourCycle === undefined && // @ts-ignore hourCycle(s) is not identified yet
+    locale.hourCycles && // @ts-ignore
+    locale.hourCycles.length) {
+      // @ts-ignore
+      hourCycle = locale.hourCycles[0];
+    }
+
+    if (hourCycle) {
+      switch (hourCycle) {
+        case 'h24':
+          return 'k';
+
+        case 'h23':
+          return 'H';
+
+        case 'h12':
+          return 'h';
+
+        case 'h11':
+          return 'K';
+
+        default:
+          throw new Error('Invalid hourCycle');
+      }
+    } // TODO: Once hourCycle is fully supported remove the following with data generation
+
+
+    var languageTag = locale.language;
+    var regionTag;
+
+    if (languageTag !== 'root') {
+      regionTag = locale.maximize().region;
+    }
+
+    var hourCycles = timeData[regionTag || ''] || timeData[languageTag || ''] || timeData["".concat(languageTag, "-001")] || timeData['001'];
+    return hourCycles[0];
+  }
+
   var _a;
   var SPACE_SEPARATOR_START_REGEX = new RegExp("^".concat(SPACE_SEPARATOR_REGEX.source, "*"));
   var SPACE_SEPARATOR_END_REGEX = new RegExp("".concat(SPACE_SEPARATOR_REGEX.source, "*$"));
@@ -3462,6 +3859,7 @@
         column: 1
       };
       this.ignoreTag = !!options.ignoreTag;
+      this.locale = options.locale;
       this.requiresOtherClause = !!options.requiresOtherClause;
       this.shouldParseSkeletons = !!options.shouldParseSkeletons;
     }
@@ -3957,11 +4355,19 @@
                   return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);
                 }
 
+                var dateTimePattern = skeleton; // Get "best match" pattern only if locale is passed, if not, let it
+                // pass as-is where `parseDateTimeSkeleton()` will throw an error
+                // for unsupported patterns.
+
+                if (this.locale) {
+                  dateTimePattern = getBestPattern(skeleton, this.locale);
+                }
+
                 var style = {
                   type: SKELETON_TYPE.dateTime,
-                  pattern: skeleton,
+                  pattern: dateTimePattern,
                   location: styleAndLocation.styleLocation,
-                  parsedOptions: this.shouldParseSkeletons ? parseDateTimeSkeleton(skeleton) : {}
+                  parsedOptions: this.shouldParseSkeletons ? parseDateTimeSkeleton(dateTimePattern) : {}
                 };
                 var type = argType === 'date' ? TYPE.date : TYPE.time;
                 return {
@@ -5072,13 +5478,17 @@
 
       this.resolvedOptions = function () {
         return {
-          locale: Intl.NumberFormat.supportedLocalesOf(_this.locales)[0]
+          locale: _this.resolvedLocale.toString()
         };
       };
 
       this.getAst = function () {
         return _this.ast;
-      };
+      }; // Defined first because it's used to build the format pattern.
+
+
+      this.locales = locales;
+      this.resolvedLocale = IntlMessageFormat.resolveLocale(locales);
 
       if (typeof message === 'string') {
         this.message = message;
@@ -5089,7 +5499,8 @@
 
 
         this.ast = IntlMessageFormat.__parse(message, {
-          ignoreTag: opts === null || opts === void 0 ? void 0 : opts.ignoreTag
+          ignoreTag: opts === null || opts === void 0 ? void 0 : opts.ignoreTag,
+          locale: this.resolvedLocale
         });
       } else {
         this.ast = message;
@@ -5101,9 +5512,7 @@
       // formats.
 
 
-      this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats); // Defined first because it's used to build the format pattern.
-
-      this.locales = locales;
+      this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats);
       this.formatters = opts && opts.formatters || createDefaultFormatters(this.formatterCache);
     }
 
@@ -5119,6 +5528,17 @@
       configurable: true
     });
     IntlMessageFormat.memoizedDefaultLocale = null;
+
+    IntlMessageFormat.resolveLocale = function (locales) {
+      var supportedLocales = Intl.NumberFormat.supportedLocalesOf(locales);
+
+      if (supportedLocales.length > 0) {
+        return new Intl.Locale(supportedLocales[0]);
+      }
+
+      return new Intl.Locale(typeof locales === 'string' ? locales : locales[0]);
+    };
+
     IntlMessageFormat.__parse = parse; // Default format options used as the prototype of the `formats` provided to the
     // constructor. These are used when constructing the internal Intl.NumberFormat
     // and Intl.DateTimeFormat instances.
@@ -6297,7 +6717,7 @@
   	"eligibility-modal.title-deferred": "<highlighted>Bezahlen Sie in Raten</highlighted> oder später per Kreditkarte mit Alma.",
   	"eligibility-modal.total": "Insgesamt",
   	"installments.today": "Heute",
-  	"payment-plan-strings.day-abbreviation": "J{numberOfDeferredDays}",
+  	"payment-plan-strings.day-abbreviation": "T{numberOfDeferredDays}",
   	"payment-plan-strings.default-message": "Bezahlen Sie in Raten mit Alma",
   	"payment-plan-strings.deferred": "{totalAmount} zu zahlen am {dueDate}",
   	"payment-plan-strings.ineligible-greater-than-max": "Bis zu {maxAmount}",
@@ -14425,7 +14845,7 @@
   });
 
   function _extends() {
-    _extends = Object.assign || function (target) {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i];
 
@@ -14438,7 +14858,6 @@
 
       return target;
     };
-
     return _extends.apply(this, arguments);
   }
 
@@ -14903,7 +15322,7 @@
      * http://api.jqueryui.com/category/ui-core/
      */
 
-    var tabbableNode = /input|select|textarea|button|object/;
+    var tabbableNode = /input|select|textarea|button|object|iframe/;
 
     function hidesContents(element) {
       var zeroSize = element.offsetWidth <= 0 && element.offsetHeight <= 0; // If the node is empty, this is good enough
@@ -16824,1143 +17243,2248 @@
   };
 
   var reactResponsive = createCommonjsModule(function (module, exports) {
-    !function (root, factory) {
-       module.exports = factory(react) ;
-    }("undefined" != typeof self ? self : commonjsGlobal, function (__WEBPACK_EXTERNAL_MODULE_1__) {
-      return function (modules) {
-        function __webpack_require__(moduleId) {
-          if (installedModules[moduleId]) return installedModules[moduleId].exports;
-          var module = installedModules[moduleId] = {
-            i: moduleId,
-            l: !1,
-            exports: {}
-          };
-          return modules[moduleId].call(module.exports, module, module.exports, __webpack_require__), module.l = !0, module.exports;
-        }
-
-        var installedModules = {};
-        return __webpack_require__.m = modules, __webpack_require__.c = installedModules, __webpack_require__.d = function (exports, name, getter) {
-          __webpack_require__.o(exports, name) || Object.defineProperty(exports, name, {
-            configurable: !1,
-            enumerable: !0,
-            get: getter
-          });
-        }, __webpack_require__.n = function (module) {
-          var getter = module && module.__esModule ? function () {
-            return module.default;
-          } : function () {
-            return module;
-          };
-          return __webpack_require__.d(getter, "a", getter), getter;
-        }, __webpack_require__.o = function (object, property) {
-          return Object.prototype.hasOwnProperty.call(object, property);
-        }, __webpack_require__.p = "", __webpack_require__(__webpack_require__.s = 8);
-      }([function (module, exports, __webpack_require__) {
-
-        var __importDefault = this && this.__importDefault || function (mod) {
-          return mod && mod.__esModule ? mod : {
-            default: mod
-          };
-        };
-
-        Object.defineProperty(exports, "__esModule", {
-          value: !0
-        });
-
-        var react_1 = __importDefault(__webpack_require__(1)),
-            matchmediaquery_1 = __importDefault(__webpack_require__(9)),
-            hyphenate_style_name_1 = __importDefault(__webpack_require__(2)),
-            shallow_equal_1 = __webpack_require__(11),
-            toQuery_1 = __importDefault(__webpack_require__(3)),
-            Context_1 = __importDefault(__webpack_require__(7)),
-            makeQuery = function (settings) {
-          return settings.query || (0, toQuery_1.default)(settings);
-        },
-            hyphenateKeys = function (obj) {
-          if (obj) {
-            return Object.keys(obj).reduce(function (result, key) {
-              return result[(0, hyphenate_style_name_1.default)(key)] = obj[key], result;
-            }, {});
-          }
-        },
-            useIsUpdate = function () {
-          var ref = react_1.default.useRef(!1);
-          return react_1.default.useEffect(function () {
-            ref.current = !0;
-          }, []), ref.current;
-        },
-            useDevice = function (deviceFromProps) {
-          var deviceFromContext = react_1.default.useContext(Context_1.default),
-              getDevice = function () {
-            return hyphenateKeys(deviceFromProps) || hyphenateKeys(deviceFromContext);
-          },
-              _a = react_1.default.useState(getDevice),
-              device = _a[0],
-              setDevice = _a[1];
-
-          return react_1.default.useEffect(function () {
-            var newDevice = getDevice();
-            (0, shallow_equal_1.shallowEqualObjects)(device, newDevice) || setDevice(newDevice);
-          }, [deviceFromProps, deviceFromContext]), device;
-        },
-            useQuery = function (settings) {
-          var getQuery = function () {
-            return makeQuery(settings);
-          },
-              _a = react_1.default.useState(getQuery),
-              query = _a[0],
-              setQuery = _a[1];
-
-          return react_1.default.useEffect(function () {
-            var newQuery = getQuery();
-            query !== newQuery && setQuery(newQuery);
-          }, [settings]), query;
-        },
-            useMatchMedia = function (query, device) {
-          var getMatchMedia = function () {
-            return (0, matchmediaquery_1.default)(query, device || {}, !!device);
-          },
-              _a = react_1.default.useState(getMatchMedia),
-              mq = _a[0],
-              setMq = _a[1],
-              isUpdate = useIsUpdate();
-
-          return react_1.default.useEffect(function () {
-            if (isUpdate) {
-              var newMq_1 = getMatchMedia();
-              return setMq(newMq_1), function () {
-                newMq_1 && newMq_1.dispose();
-              };
-            }
-          }, [query, device]), mq;
-        },
-            useMatches = function (mediaQuery) {
-          var _a = react_1.default.useState(mediaQuery.matches),
-              matches = _a[0],
-              setMatches = _a[1];
-
-          return react_1.default.useEffect(function () {
-            var updateMatches = function () {
-              setMatches(mediaQuery.matches);
-            };
+    (function webpackUniversalModuleDefinition(root, factory) {
+      module.exports = factory(react);
+    })(commonjsGlobal, __WEBPACK_EXTERNAL_MODULE_react__ => {
+      return (
+        /******/
+        (() => {
+          // webpackBootstrap
+
+          /******/
+          var __webpack_modules__ = {
+            /***/
+            "./node_modules/css-mediaquery/index.js":
+            /*!**********************************************!*\
+              !*** ./node_modules/css-mediaquery/index.js ***!
+              \**********************************************/
+
+            /***/
+            (__unused_webpack_module, exports) => {
+              /*
+              Copyright (c) 2014, Yahoo! Inc. All rights reserved.
+              Copyrights licensed under the New BSD License.
+              See the accompanying LICENSE file for terms.
+              */
+
+              exports.match = matchQuery;
+              exports.parse = parseQuery; // -----------------------------------------------------------------------------
+
+              var RE_MEDIA_QUERY = /(?:(only|not)?\s*([^\s\(\)]+)(?:\s*and)?\s*)?(.+)?/i,
+                  RE_MQ_EXPRESSION = /\(\s*([^\s\:\)]+)\s*(?:\:\s*([^\s\)]+))?\s*\)/,
+                  RE_MQ_FEATURE = /^(?:(min|max)-)?(.+)/,
+                  RE_LENGTH_UNIT = /(em|rem|px|cm|mm|in|pt|pc)?$/,
+                  RE_RESOLUTION_UNIT = /(dpi|dpcm|dppx)?$/;
+
+              function matchQuery(mediaQuery, values) {
+                return parseQuery(mediaQuery).some(function (query) {
+                  var inverse = query.inverse; // Either the parsed or specified `type` is "all", or the types must be
+                  // equal for a match.
+
+                  var typeMatch = query.type === 'all' || values.type === query.type; // Quit early when `type` doesn't match, but take "not" into account.
+
+                  if (typeMatch && inverse || !(typeMatch || inverse)) {
+                    return false;
+                  }
 
-            return mediaQuery.addListener(updateMatches), updateMatches(), function () {
-              mediaQuery.removeListener(updateMatches);
-            };
-          }, [mediaQuery]), matches;
-        },
-            useMediaQuery = function (settings, device, onChange) {
-          var deviceSettings = useDevice(device),
-              query = useQuery(settings);
-          if (!query) throw new Error("Invalid or missing MediaQuery!");
-          var mq = useMatchMedia(query, deviceSettings),
-              matches = useMatches(mq),
-              isUpdate = useIsUpdate();
-          return react_1.default.useEffect(function () {
-            isUpdate && onChange && onChange(matches);
-          }, [matches]), react_1.default.useEffect(function () {
-            return function () {
-              mq && mq.dispose();
-            };
-          }, []), matches;
-        };
+                  var expressionsMatch = query.expressions.every(function (expression) {
+                    var feature = expression.feature,
+                        modifier = expression.modifier,
+                        expValue = expression.value,
+                        value = values[feature]; // Missing or falsy values don't match.
 
-        exports.default = useMediaQuery;
-      }, function (module, exports) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
-      }, function (module, __webpack_exports__, __webpack_require__) {
+                    if (!value) {
+                      return false;
+                    }
 
-        function toHyphenLower(match) {
-          return "-" + match.toLowerCase();
-        }
+                    switch (feature) {
+                      case 'orientation':
+                      case 'scan':
+                        return value.toLowerCase() === expValue.toLowerCase();
+
+                      case 'width':
+                      case 'height':
+                      case 'device-width':
+                      case 'device-height':
+                        expValue = toPx(expValue);
+                        value = toPx(value);
+                        break;
+
+                      case 'resolution':
+                        expValue = toDpi(expValue);
+                        value = toDpi(value);
+                        break;
+
+                      case 'aspect-ratio':
+                      case 'device-aspect-ratio':
+                      case
+                      /* Deprecated */
+                      'device-pixel-ratio':
+                        expValue = toDecimal(expValue);
+                        value = toDecimal(value);
+                        break;
+
+                      case 'grid':
+                      case 'color':
+                      case 'color-index':
+                      case 'monochrome':
+                        expValue = parseInt(expValue, 10) || 1;
+                        value = parseInt(value, 10) || 0;
+                        break;
+                    }
 
-        function hyphenateStyleName(name) {
-          if (cache.hasOwnProperty(name)) return cache[name];
-          var hName = name.replace(uppercasePattern, toHyphenLower);
-          return cache[name] = msPattern.test(hName) ? "-" + hName : hName;
-        }
+                    switch (modifier) {
+                      case 'min':
+                        return value >= expValue;
 
-        Object.defineProperty(__webpack_exports__, "__esModule", {
-          value: !0
-        });
-        var uppercasePattern = /[A-Z]/g,
-            msPattern = /^ms-/,
-            cache = {};
-        __webpack_exports__.default = hyphenateStyleName;
-      }, function (module, exports, __webpack_require__) {
-
-        var __importDefault = this && this.__importDefault || function (mod) {
-          return mod && mod.__esModule ? mod : {
-            default: mod
-          };
-        };
+                      case 'max':
+                        return value <= expValue;
 
-        Object.defineProperty(exports, "__esModule", {
-          value: !0
-        });
+                      default:
+                        return value === expValue;
+                    }
+                  });
+                  return expressionsMatch && !inverse || !expressionsMatch && inverse;
+                });
+              }
 
-        var hyphenate_style_name_1 = __importDefault(__webpack_require__(2)),
-            mediaQuery_1 = __importDefault(__webpack_require__(12)),
-            negate = function (cond) {
-          return "not ".concat(cond);
-        },
-            keyVal = function (k, v) {
-          var realKey = (0, hyphenate_style_name_1.default)(k);
-          return "number" == typeof v && (v = "".concat(v, "px")), !0 === v ? realKey : !1 === v ? negate(realKey) : "(".concat(realKey, ": ").concat(v, ")");
-        },
-            join = function (conds) {
-          return conds.join(" and ");
-        },
-            toQuery = function (obj) {
-          var rules = [];
-          return Object.keys(mediaQuery_1.default.all).forEach(function (k) {
-            var v = obj[k];
-            null != v && rules.push(keyVal(k, v));
-          }), join(rules);
-        };
+              function parseQuery(mediaQuery) {
+                return mediaQuery.split(',').map(function (query) {
+                  query = query.trim();
+                  var captures = query.match(RE_MEDIA_QUERY),
+                      modifier = captures[1],
+                      type = captures[2],
+                      expressions = captures[3] || '',
+                      parsed = {};
+                  parsed.inverse = !!modifier && modifier.toLowerCase() === 'not';
+                  parsed.type = type ? type.toLowerCase() : 'all'; // Split expressions into a list.
+
+                  expressions = expressions.match(/\([^\)]+\)/g) || [];
+                  parsed.expressions = expressions.map(function (expression) {
+                    var captures = expression.match(RE_MQ_EXPRESSION),
+                        feature = captures[1].toLowerCase().match(RE_MQ_FEATURE);
+                    return {
+                      modifier: feature[1],
+                      feature: feature[2],
+                      value: captures[2]
+                    };
+                  });
+                  return parsed;
+                });
+              } // -- Utilities ----------------------------------------------------------------
 
-        exports.default = toQuery;
-      }, function (module, exports, __webpack_require__) {
 
-        module.exports = __webpack_require__(14);
-      }, function (module, exports, __webpack_require__) {
+              function toDecimal(ratio) {
+                var decimal = Number(ratio),
+                    numbers;
 
-        module.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
-      }, function (module, exports) {
-        module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
-      }, function (module, exports, __webpack_require__) {
+                if (!decimal) {
+                  numbers = ratio.match(/^(\d+)\s*\/\s*(\d+)$/);
+                  decimal = numbers[1] / numbers[2];
+                }
 
-        var __importDefault = this && this.__importDefault || function (mod) {
-          return mod && mod.__esModule ? mod : {
-            default: mod
-          };
-        };
+                return decimal;
+              }
 
-        Object.defineProperty(exports, "__esModule", {
-          value: !0
-        });
+              function toDpi(resolution) {
+                var value = parseFloat(resolution),
+                    units = String(resolution).match(RE_RESOLUTION_UNIT)[1];
 
-        var react_1 = __importDefault(__webpack_require__(1)),
-            Context = react_1.default.createContext(void 0);
+                switch (units) {
+                  case 'dpcm':
+                    return value / 2.54;
 
-        exports.default = Context;
-      }, function (module, exports, __webpack_require__) {
+                  case 'dppx':
+                    return value * 96;
 
-        var __importDefault = this && this.__importDefault || function (mod) {
-          return mod && mod.__esModule ? mod : {
-            default: mod
-          };
-        };
+                  default:
+                    return value;
+                }
+              }
 
-        Object.defineProperty(exports, "__esModule", {
-          value: !0
-        }), exports.Context = exports.toQuery = exports.useMediaQuery = exports.default = void 0;
+              function toPx(length) {
+                var value = parseFloat(length),
+                    units = String(length).match(RE_LENGTH_UNIT)[1];
 
-        var useMediaQuery_1 = __importDefault(__webpack_require__(0));
+                switch (units) {
+                  case 'em':
+                    return value * 16;
 
-        exports.useMediaQuery = useMediaQuery_1.default;
+                  case 'rem':
+                    return value * 16;
 
-        var Component_1 = __importDefault(__webpack_require__(18));
+                  case 'cm':
+                    return value * 96 / 2.54;
 
-        exports.default = Component_1.default;
+                  case 'mm':
+                    return value * 96 / 2.54 / 10;
 
-        var toQuery_1 = __importDefault(__webpack_require__(3));
+                  case 'in':
+                    return value * 96;
 
-        exports.toQuery = toQuery_1.default;
+                  case 'pt':
+                    return value * 72;
 
-        var Context_1 = __importDefault(__webpack_require__(7));
+                  case 'pc':
+                    return value * 72 / 12;
 
-        exports.Context = Context_1.default;
-      }, function (module, exports, __webpack_require__) {
+                  default:
+                    return value;
+                }
+              }
+              /***/
 
-        function Mql(query, values, forceStatic) {
-          function addListener(listener) {
-            mql && mql.addListener(listener);
-          }
+            },
 
-          function removeListener(listener) {
-            mql && mql.removeListener(listener);
-          }
+            /***/
+            "./node_modules/hyphenate-style-name/index.js":
+            /*!****************************************************!*\
+              !*** ./node_modules/hyphenate-style-name/index.js ***!
+              \****************************************************/
 
-          function update(evt) {
-            self.matches = evt.matches, self.media = evt.media;
-          }
+            /***/
+            (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-          function dispose() {
-            mql && mql.removeListener(update);
-          }
+              __webpack_require__.r(__webpack_exports__);
+              /* harmony export */
 
-          var self = this;
 
-          if (dynamicMatch && !forceStatic) {
-            var mql = dynamicMatch.call(window, query);
-            this.matches = mql.matches, this.media = mql.media, mql.addListener(update);
-          } else this.matches = staticMatch(query, values), this.media = query;
+              __webpack_require__.d(__webpack_exports__, {
+                /* harmony export */
+                "default": () => __WEBPACK_DEFAULT_EXPORT__
+                /* harmony export */
 
-          this.addListener = addListener, this.removeListener = removeListener, this.dispose = dispose;
-        }
+              });
+              /* eslint-disable no-var, prefer-template */
 
-        function matchMedia(query, values, forceStatic) {
-          return new Mql(query, values, forceStatic);
-        }
 
-        var staticMatch = __webpack_require__(10).match,
-            dynamicMatch = "undefined" != typeof window ? window.matchMedia : null;
-
-        module.exports = matchMedia;
-      }, function (module, exports, __webpack_require__) {
-
-        function matchQuery(mediaQuery, values) {
-          return parseQuery(mediaQuery).some(function (query) {
-            var inverse = query.inverse,
-                typeMatch = "all" === query.type || values.type === query.type;
-            if (typeMatch && inverse || !typeMatch && !inverse) return !1;
-            var expressionsMatch = query.expressions.every(function (expression) {
-              var feature = expression.feature,
-                  modifier = expression.modifier,
-                  expValue = expression.value,
-                  value = values[feature];
-              if (!value) return !1;
-
-              switch (feature) {
-                case "orientation":
-                case "scan":
-                  return value.toLowerCase() === expValue.toLowerCase();
-
-                case "width":
-                case "height":
-                case "device-width":
-                case "device-height":
-                  expValue = toPx(expValue), value = toPx(value);
-                  break;
+              var uppercasePattern = /[A-Z]/g;
+              var msPattern = /^ms-/;
+              var cache = {};
 
-                case "resolution":
-                  expValue = toDpi(expValue), value = toDpi(value);
-                  break;
+              function toHyphenLower(match) {
+                return '-' + match.toLowerCase();
+              }
 
-                case "aspect-ratio":
-                case "device-aspect-ratio":
-                case "device-pixel-ratio":
-                  expValue = toDecimal(expValue), value = toDecimal(value);
-                  break;
+              function hyphenateStyleName(name) {
+                if (cache.hasOwnProperty(name)) {
+                  return cache[name];
+                }
 
-                case "grid":
-                case "color":
-                case "color-index":
-                case "monochrome":
-                  expValue = parseInt(expValue, 10) || 1, value = parseInt(value, 10) || 0;
+                var hName = name.replace(uppercasePattern, toHyphenLower);
+                return cache[name] = msPattern.test(hName) ? '-' + hName : hName;
               }
+              /* harmony default export */
 
-              switch (modifier) {
-                case "min":
-                  return value >= expValue;
 
-                case "max":
-                  return value <= expValue;
+              const __WEBPACK_DEFAULT_EXPORT__ = hyphenateStyleName;
+              /***/
+            },
 
-                default:
-                  return value === expValue;
-              }
-            });
-            return expressionsMatch && !inverse || !expressionsMatch && inverse;
-          });
-        }
+            /***/
+            "./node_modules/matchmediaquery/index.js":
+            /*!***********************************************!*\
+              !*** ./node_modules/matchmediaquery/index.js ***!
+              \***********************************************/
 
-        function parseQuery(mediaQuery) {
-          return mediaQuery.split(",").map(function (query) {
-            query = query.trim();
-            var captures = query.match(RE_MEDIA_QUERY),
-                modifier = captures[1],
-                type = captures[2],
-                expressions = captures[3] || "",
-                parsed = {};
-            return parsed.inverse = !!modifier && "not" === modifier.toLowerCase(), parsed.type = type ? type.toLowerCase() : "all", expressions = expressions.match(/\([^\)]+\)/g) || [], parsed.expressions = expressions.map(function (expression) {
-              var captures = expression.match(RE_MQ_EXPRESSION),
-                  feature = captures[1].toLowerCase().match(RE_MQ_FEATURE);
-              return {
-                modifier: feature[1],
-                feature: feature[2],
-                value: captures[2]
-              };
-            }), parsed;
-          });
-        }
+            /***/
+            (module, __unused_webpack_exports, __webpack_require__) => {
 
-        function toDecimal(ratio) {
-          var numbers,
-              decimal = Number(ratio);
-          return decimal || (numbers = ratio.match(/^(\d+)\s*\/\s*(\d+)$/), decimal = numbers[1] / numbers[2]), decimal;
-        }
+              var staticMatch = __webpack_require__(
+              /*! css-mediaquery */
+              "./node_modules/css-mediaquery/index.js").match;
 
-        function toDpi(resolution) {
-          var value = parseFloat(resolution);
+              var dynamicMatch = typeof window !== 'undefined' ? window.matchMedia : null; // our fake MediaQueryList
 
-          switch (String(resolution).match(RE_RESOLUTION_UNIT)[1]) {
-            case "dpcm":
-              return value / 2.54;
+              function Mql(query, values, forceStatic) {
+                var self = this;
 
-            case "dppx":
-              return 96 * value;
+                if (dynamicMatch && !forceStatic) {
+                  var mql = dynamicMatch.call(window, query);
+                  this.matches = mql.matches;
+                  this.media = mql.media; // TODO: is there a time it makes sense to remove this listener?
 
-            default:
-              return value;
-          }
-        }
+                  mql.addListener(update);
+                } else {
+                  this.matches = staticMatch(query, values);
+                  this.media = query;
+                }
 
-        function toPx(length) {
-          var value = parseFloat(length);
+                this.addListener = addListener;
+                this.removeListener = removeListener;
+                this.dispose = dispose;
 
-          switch (String(length).match(RE_LENGTH_UNIT)[1]) {
-            case "em":
-            case "rem":
-              return 16 * value;
+                function addListener(listener) {
+                  if (mql) {
+                    mql.addListener(listener);
+                  }
+                }
 
-            case "cm":
-              return 96 * value / 2.54;
+                function removeListener(listener) {
+                  if (mql) {
+                    mql.removeListener(listener);
+                  }
+                } // update ourselves!
 
-            case "mm":
-              return 96 * value / 2.54 / 10;
 
-            case "in":
-              return 96 * value;
+                function update(evt) {
+                  self.matches = evt.matches;
+                  self.media = evt.media;
+                }
 
-            case "pt":
-              return 72 * value;
+                function dispose() {
+                  if (mql) {
+                    mql.removeListener(update);
+                  }
+                }
+              }
 
-            case "pc":
-              return 72 * value / 12;
+              function matchMedia(query, values, forceStatic) {
+                return new Mql(query, values, forceStatic);
+              }
 
-            default:
-              return value;
-          }
-        }
+              module.exports = matchMedia;
+              /***/
+            },
 
-        exports.match = matchQuery, exports.parse = parseQuery;
-        var RE_MEDIA_QUERY = /(?:(only|not)?\s*([^\s\(\)]+)(?:\s*and)?\s*)?(.+)?/i,
-            RE_MQ_EXPRESSION = /\(\s*([^\s\:\)]+)\s*(?:\:\s*([^\s\)]+))?\s*\)/,
-            RE_MQ_FEATURE = /^(?:(min|max)-)?(.+)/,
-            RE_LENGTH_UNIT = /(em|rem|px|cm|mm|in|pt|pc)?$/,
-            RE_RESOLUTION_UNIT = /(dpi|dpcm|dppx)?$/;
-      }, function (module, __webpack_exports__, __webpack_require__) {
-
-        function shallowEqualObjects(objA, objB) {
-          if (objA === objB) return !0;
-          if (!objA || !objB) return !1;
-          var aKeys = Object.keys(objA),
-              bKeys = Object.keys(objB),
-              len = aKeys.length;
-          if (bKeys.length !== len) return !1;
-
-          for (var i = 0; i < len; i++) {
-            var key = aKeys[i];
-            if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) return !1;
-          }
+            /***/
+            "./node_modules/object-assign/index.js":
+            /*!*********************************************!*\
+              !*** ./node_modules/object-assign/index.js ***!
+              \*********************************************/
+
+            /***/
+            module => {
+              /*
+              object-assign
+              (c) Sindre Sorhus
+              @license MIT
+              */
+
+              /* eslint-disable no-unused-vars */
+
+              var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+              var hasOwnProperty = Object.prototype.hasOwnProperty;
+              var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+              function toObject(val) {
+                if (val === null || val === undefined) {
+                  throw new TypeError('Object.assign cannot be called with null or undefined');
+                }
 
-          return !0;
-        }
+                return Object(val);
+              }
 
-        function shallowEqualArrays(arrA, arrB) {
-          if (arrA === arrB) return !0;
-          if (!arrA || !arrB) return !1;
-          var len = arrA.length;
-          if (arrB.length !== len) return !1;
+              function shouldUseNative() {
+                try {
+                  if (!Object.assign) {
+                    return false;
+                  } // Detect buggy property enumeration order in older V8 versions.
+                  // https://bugs.chromium.org/p/v8/issues/detail?id=4118
 
-          for (var i = 0; i < len; i++) if (arrA[i] !== arrB[i]) return !1;
 
-          return !0;
-        }
+                  var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
 
-        Object.defineProperty(__webpack_exports__, "__esModule", {
-          value: !0
-        }), __webpack_require__.d(__webpack_exports__, "shallowEqualArrays", function () {
-          return shallowEqualArrays;
-        }), __webpack_require__.d(__webpack_exports__, "shallowEqualObjects", function () {
-          return shallowEqualObjects;
-        });
-      }, function (module, exports, __webpack_require__) {
+                  test1[5] = 'de';
 
-        var __assign = this && this.__assign || function () {
-          return __assign = Object.assign || function (t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-              s = arguments[i];
+                  if (Object.getOwnPropertyNames(test1)[0] === '5') {
+                    return false;
+                  } // https://bugs.chromium.org/p/v8/issues/detail?id=3056
 
-              for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && (t[p] = s[p]);
-            }
 
-            return t;
-          }, __assign.apply(this, arguments);
-        },
-            __rest = this && this.__rest || function (s, e) {
-          var t = {};
+                  var test2 = {};
 
-          for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0 && (t[p] = s[p]);
+                  for (var i = 0; i < 10; i++) {
+                    test2['_' + String.fromCharCode(i)] = i;
+                  }
 
-          if (null != s && "function" == typeof Object.getOwnPropertySymbols) for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]) && (t[p[i]] = s[p[i]]);
-          return t;
-        },
-            __importDefault = this && this.__importDefault || function (mod) {
-          return mod && mod.__esModule ? mod : {
-            default: mod
-          };
-        };
+                  var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+                    return test2[n];
+                  });
 
-        Object.defineProperty(exports, "__esModule", {
-          value: !0
-        });
+                  if (order2.join('') !== '0123456789') {
+                    return false;
+                  } // https://bugs.chromium.org/p/v8/issues/detail?id=3056
 
-        var prop_types_1 = __importDefault(__webpack_require__(13)),
-            stringOrNumber = prop_types_1.default.oneOfType([prop_types_1.default.string, prop_types_1.default.number]),
-            types = {
-          all: prop_types_1.default.bool,
-          grid: prop_types_1.default.bool,
-          aural: prop_types_1.default.bool,
-          braille: prop_types_1.default.bool,
-          handheld: prop_types_1.default.bool,
-          print: prop_types_1.default.bool,
-          projection: prop_types_1.default.bool,
-          screen: prop_types_1.default.bool,
-          tty: prop_types_1.default.bool,
-          tv: prop_types_1.default.bool,
-          embossed: prop_types_1.default.bool
-        },
-            matchers = {
-          orientation: prop_types_1.default.oneOf(["portrait", "landscape"]),
-          scan: prop_types_1.default.oneOf(["progressive", "interlace"]),
-          aspectRatio: prop_types_1.default.string,
-          deviceAspectRatio: prop_types_1.default.string,
-          height: stringOrNumber,
-          deviceHeight: stringOrNumber,
-          width: stringOrNumber,
-          deviceWidth: stringOrNumber,
-          color: prop_types_1.default.bool,
-          colorIndex: prop_types_1.default.bool,
-          monochrome: prop_types_1.default.bool,
-          resolution: stringOrNumber,
-          type: Object.keys(types)
-        },
-            featureMatchers = __rest(matchers, ["type"]),
-            features = __assign({
-          minAspectRatio: prop_types_1.default.string,
-          maxAspectRatio: prop_types_1.default.string,
-          minDeviceAspectRatio: prop_types_1.default.string,
-          maxDeviceAspectRatio: prop_types_1.default.string,
-          minHeight: stringOrNumber,
-          maxHeight: stringOrNumber,
-          minDeviceHeight: stringOrNumber,
-          maxDeviceHeight: stringOrNumber,
-          minWidth: stringOrNumber,
-          maxWidth: stringOrNumber,
-          minDeviceWidth: stringOrNumber,
-          maxDeviceWidth: stringOrNumber,
-          minColor: prop_types_1.default.number,
-          maxColor: prop_types_1.default.number,
-          minColorIndex: prop_types_1.default.number,
-          maxColorIndex: prop_types_1.default.number,
-          minMonochrome: prop_types_1.default.number,
-          maxMonochrome: prop_types_1.default.number,
-          minResolution: stringOrNumber,
-          maxResolution: stringOrNumber
-        }, featureMatchers),
-            all = __assign(__assign({}, types), features);
-
-        exports.default = {
-          all: all,
-          types: types,
-          matchers: matchers,
-          features: features
-        };
-      }, function (module, exports, __webpack_require__) {
-        var ReactIs = __webpack_require__(4);
 
-        module.exports = __webpack_require__(15)(ReactIs.isElement, !0);
-      }, function (module, exports, __webpack_require__) {
+                  var test3 = {};
+                  'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+                    test3[letter] = letter;
+                  });
 
-        !function () {
-          function isValidElementType(type) {
-            return "string" == typeof type || "function" == typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" == typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
-          }
+                  if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') {
+                    return false;
+                  }
 
-          function typeOf(object) {
-            if ("object" == typeof object && null !== object) {
-              var $$typeof = object.$$typeof;
+                  return true;
+                } catch (err) {
+                  // We don't expect any of the above to throw, but better to be safe.
+                  return false;
+                }
+              }
 
-              switch ($$typeof) {
-                case REACT_ELEMENT_TYPE:
-                  var type = object.type;
+              module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+                var from;
+                var to = toObject(target);
+                var symbols;
 
-                  switch (type) {
-                    case REACT_ASYNC_MODE_TYPE:
-                    case REACT_CONCURRENT_MODE_TYPE:
-                    case REACT_FRAGMENT_TYPE:
-                    case REACT_PROFILER_TYPE:
-                    case REACT_STRICT_MODE_TYPE:
-                    case REACT_SUSPENSE_TYPE:
-                      return type;
+                for (var s = 1; s < arguments.length; s++) {
+                  from = Object(arguments[s]);
 
-                    default:
-                      var $$typeofType = type && type.$$typeof;
+                  for (var key in from) {
+                    if (hasOwnProperty.call(from, key)) {
+                      to[key] = from[key];
+                    }
+                  }
 
-                      switch ($$typeofType) {
-                        case REACT_CONTEXT_TYPE:
-                        case REACT_FORWARD_REF_TYPE:
-                        case REACT_LAZY_TYPE:
-                        case REACT_MEMO_TYPE:
-                        case REACT_PROVIDER_TYPE:
-                          return $$typeofType;
+                  if (getOwnPropertySymbols) {
+                    symbols = getOwnPropertySymbols(from);
 
-                        default:
-                          return $$typeof;
+                    for (var i = 0; i < symbols.length; i++) {
+                      if (propIsEnumerable.call(from, symbols[i])) {
+                        to[symbols[i]] = from[symbols[i]];
                       }
-
+                    }
                   }
+                }
 
-                case REACT_PORTAL_TYPE:
-                  return $$typeof;
-              }
-            }
-          }
-
-          function isAsyncMode(object) {
-            return hasWarnedAboutDeprecatedIsAsyncMode || (hasWarnedAboutDeprecatedIsAsyncMode = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
-          }
+                return to;
+              };
+              /***/
+            },
 
-          function isConcurrentMode(object) {
-            return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
-          }
+            /***/
+            "./node_modules/prop-types/checkPropTypes.js":
+            /*!***************************************************!*\
+              !*** ./node_modules/prop-types/checkPropTypes.js ***!
+              \***************************************************/
 
-          function isContextConsumer(object) {
-            return typeOf(object) === REACT_CONTEXT_TYPE;
-          }
+            /***/
+            (module, __unused_webpack_exports, __webpack_require__) => {
+              /**
+               * Copyright (c) 2013-present, Facebook, Inc.
+               *
+               * This source code is licensed under the MIT license found in the
+               * LICENSE file in the root directory of this source tree.
+               */
 
-          function isContextProvider(object) {
-            return typeOf(object) === REACT_PROVIDER_TYPE;
-          }
+              var printWarning = function () {};
 
-          function isElement(object) {
-            return "object" == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
-          }
+              {
+                var ReactPropTypesSecret = __webpack_require__(
+                /*! ./lib/ReactPropTypesSecret */
+                "./node_modules/prop-types/lib/ReactPropTypesSecret.js");
 
-          function isForwardRef(object) {
-            return typeOf(object) === REACT_FORWARD_REF_TYPE;
-          }
+                var loggedTypeFailures = {};
 
-          function isFragment(object) {
-            return typeOf(object) === REACT_FRAGMENT_TYPE;
-          }
+                var has = __webpack_require__(
+                /*! ./lib/has */
+                "./node_modules/prop-types/lib/has.js");
 
-          function isLazy(object) {
-            return typeOf(object) === REACT_LAZY_TYPE;
-          }
+                printWarning = function (text) {
+                  var message = 'Warning: ' + text;
 
-          function isMemo(object) {
-            return typeOf(object) === REACT_MEMO_TYPE;
-          }
+                  if (typeof console !== 'undefined') {
+                    console.error(message);
+                  }
 
-          function isPortal(object) {
-            return typeOf(object) === REACT_PORTAL_TYPE;
-          }
+                  try {
+                    // --- Welcome to debugging React ---
+                    // This error was thrown as a convenience so that you can use this stack
+                    // to find the callsite that caused this warning to fire.
+                    throw new Error(message);
+                  } catch (x) {
+                    /**/
+                  }
+                };
+              }
+              /**
+               * Assert that the values match with the type specs.
+               * Error messages are memorized and will only be shown once.
+               *
+               * @param {object} typeSpecs Map of name to a ReactPropType
+               * @param {object} values Runtime values that need to be type-checked
+               * @param {string} location e.g. "prop", "context", "child context"
+               * @param {string} componentName Name of the component for error messages.
+               * @param {?Function} getStack Returns the component stack.
+               * @private
+               */
+
+
+              function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+                {
+                  for (var typeSpecName in typeSpecs) {
+                    if (has(typeSpecs, typeSpecName)) {
+                      var error; // Prop type validation may throw. In case they do, we don't want to
+                      // fail the render phase where it didn't fail before. So we log it.
+                      // After these have been cleaned up, we'll let them throw.
+
+                      try {
+                        // This is intentionally an invariant that gets caught. It's the same
+                        // behavior as without this statement except with a better message.
+                        if (typeof typeSpecs[typeSpecName] !== 'function') {
+                          var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
+                          err.name = 'Invariant Violation';
+                          throw err;
+                        }
+
+                        error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+                      } catch (ex) {
+                        error = ex;
+                      }
 
-          function isProfiler(object) {
-            return typeOf(object) === REACT_PROFILER_TYPE;
-          }
+                      if (error && !(error instanceof Error)) {
+                        printWarning((componentName || 'React class') + ': type specification of ' + location + ' `' + typeSpecName + '` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).');
+                      }
 
-          function isStrictMode(object) {
-            return typeOf(object) === REACT_STRICT_MODE_TYPE;
-          }
+                      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+                        // Only monitor this failure once because there tends to be a lot of the
+                        // same error.
+                        loggedTypeFailures[error.message] = true;
+                        var stack = getStack ? getStack() : '';
+                        printWarning('Failed ' + location + ' type: ' + error.message + (stack != null ? stack : ''));
+                      }
+                    }
+                  }
+                }
+              }
+              /**
+               * Resets warning cache when testing.
+               *
+               * @private
+               */
 
-          function isSuspense(object) {
-            return typeOf(object) === REACT_SUSPENSE_TYPE;
-          }
 
-          var hasSymbol = "function" == typeof Symbol && Symbol.for,
-              REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103,
-              REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106,
-              REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107,
-              REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108,
-              REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114,
-              REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109,
-              REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110,
-              REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111,
-              REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111,
-              REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112,
-              REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113,
-              REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120,
-              REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115,
-              REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116,
-              REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121,
-              REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117,
-              REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118,
-              REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119,
-              AsyncMode = REACT_ASYNC_MODE_TYPE,
-              ConcurrentMode = REACT_CONCURRENT_MODE_TYPE,
-              ContextConsumer = REACT_CONTEXT_TYPE,
-              ContextProvider = REACT_PROVIDER_TYPE,
-              Element = REACT_ELEMENT_TYPE,
-              ForwardRef = REACT_FORWARD_REF_TYPE,
-              Fragment = REACT_FRAGMENT_TYPE,
-              Lazy = REACT_LAZY_TYPE,
-              Memo = REACT_MEMO_TYPE,
-              Portal = REACT_PORTAL_TYPE,
-              Profiler = REACT_PROFILER_TYPE,
-              StrictMode = REACT_STRICT_MODE_TYPE,
-              Suspense = REACT_SUSPENSE_TYPE,
-              hasWarnedAboutDeprecatedIsAsyncMode = !1;
-          exports.AsyncMode = AsyncMode, exports.ConcurrentMode = ConcurrentMode, exports.ContextConsumer = ContextConsumer, exports.ContextProvider = ContextProvider, exports.Element = Element, exports.ForwardRef = ForwardRef, exports.Fragment = Fragment, exports.Lazy = Lazy, exports.Memo = Memo, exports.Portal = Portal, exports.Profiler = Profiler, exports.StrictMode = StrictMode, exports.Suspense = Suspense, exports.isAsyncMode = isAsyncMode, exports.isConcurrentMode = isConcurrentMode, exports.isContextConsumer = isContextConsumer, exports.isContextProvider = isContextProvider, exports.isElement = isElement, exports.isForwardRef = isForwardRef, exports.isFragment = isFragment, exports.isLazy = isLazy, exports.isMemo = isMemo, exports.isPortal = isPortal, exports.isProfiler = isProfiler, exports.isStrictMode = isStrictMode, exports.isSuspense = isSuspense, exports.isValidElementType = isValidElementType, exports.typeOf = typeOf;
-        }();
-      }, function (module, exports, __webpack_require__) {
-
-        function emptyFunctionThatReturnsNull() {
-          return null;
-        }
+              checkPropTypes.resetWarningCache = function () {
+                {
+                  loggedTypeFailures = {};
+                }
+              };
 
-        var ReactIs = __webpack_require__(4),
-            assign = __webpack_require__(16),
-            ReactPropTypesSecret = __webpack_require__(5),
-            has = __webpack_require__(6),
-            checkPropTypes = __webpack_require__(17),
-            printWarning = function () {};
+              module.exports = checkPropTypes;
+              /***/
+            },
 
-        printWarning = function (text) {
-          var message = "Warning: " + text;
-          "undefined" != typeof console && console.error(message);
+            /***/
+            "./node_modules/prop-types/factoryWithTypeCheckers.js":
+            /*!************************************************************!*\
+              !*** ./node_modules/prop-types/factoryWithTypeCheckers.js ***!
+              \************************************************************/
+
+            /***/
+            (module, __unused_webpack_exports, __webpack_require__) => {
+              /**
+               * Copyright (c) 2013-present, Facebook, Inc.
+               *
+               * This source code is licensed under the MIT license found in the
+               * LICENSE file in the root directory of this source tree.
+               */
+
+              var ReactIs = __webpack_require__(
+              /*! react-is */
+              "./node_modules/react-is/index.js");
+
+              var assign = __webpack_require__(
+              /*! object-assign */
+              "./node_modules/object-assign/index.js");
+
+              var ReactPropTypesSecret = __webpack_require__(
+              /*! ./lib/ReactPropTypesSecret */
+              "./node_modules/prop-types/lib/ReactPropTypesSecret.js");
+
+              var has = __webpack_require__(
+              /*! ./lib/has */
+              "./node_modules/prop-types/lib/has.js");
+
+              var checkPropTypes = __webpack_require__(
+              /*! ./checkPropTypes */
+              "./node_modules/prop-types/checkPropTypes.js");
+
+              var printWarning = function () {};
+
+              {
+                printWarning = function (text) {
+                  var message = 'Warning: ' + text;
+
+                  if (typeof console !== 'undefined') {
+                    console.error(message);
+                  }
 
-          try {
-            throw new Error(message);
-          } catch (x) {}
-        }, module.exports = function (isValidElement, throwOnDirectAccess) {
-          function getIteratorFn(maybeIterable) {
-            var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
-            if ("function" == typeof iteratorFn) return iteratorFn;
-          }
+                  try {
+                    // --- Welcome to debugging React ---
+                    // This error was thrown as a convenience so that you can use this stack
+                    // to find the callsite that caused this warning to fire.
+                    throw new Error(message);
+                  } catch (x) {}
+                };
+              }
 
-          function is(x, y) {
-            return x === y ? 0 !== x || 1 / x == 1 / y : x !== x && y !== y;
-          }
+              function emptyFunctionThatReturnsNull() {
+                return null;
+              }
 
-          function PropTypeError(message, data) {
-            this.message = message, this.data = data && "object" == typeof data ? data : {}, this.stack = "";
-          }
+              module.exports = function (isValidElement, throwOnDirectAccess) {
+                /* global Symbol */
+                var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+                var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+                /**
+                 * Returns the iterator method function contained on the iterable object.
+                 *
+                 * Be sure to invoke the function with the iterable as context:
+                 *
+                 *     var iteratorFn = getIteratorFn(myIterable);
+                 *     if (iteratorFn) {
+                 *       var iterator = iteratorFn.call(myIterable);
+                 *       ...
+                 *     }
+                 *
+                 * @param {?object} maybeIterable
+                 * @return {?function}
+                 */
+
+                function getIteratorFn(maybeIterable) {
+                  var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+
+                  if (typeof iteratorFn === 'function') {
+                    return iteratorFn;
+                  }
+                }
+                /**
+                 * Collection of methods that allow declaration and validation of props that are
+                 * supplied to React components. Example usage:
+                 *
+                 *   var Props = require('ReactPropTypes');
+                 *   var MyArticle = React.createClass({
+                 *     propTypes: {
+                 *       // An optional string prop named "description".
+                 *       description: Props.string,
+                 *
+                 *       // A required enum prop named "category".
+                 *       category: Props.oneOf(['News','Photos']).isRequired,
+                 *
+                 *       // A prop named "dialog" that requires an instance of Dialog.
+                 *       dialog: Props.instanceOf(Dialog).isRequired
+                 *     },
+                 *     render: function() { ... }
+                 *   });
+                 *
+                 * A more formal specification of how these methods are used:
+                 *
+                 *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+                 *   decl := ReactPropTypes.{type}(.isRequired)?
+                 *
+                 * Each and every declaration produces a function with the same signature. This
+                 * allows the creation of custom validation functions. For example:
+                 *
+                 *  var MyLink = React.createClass({
+                 *    propTypes: {
+                 *      // An optional string or URI prop named "href".
+                 *      href: function(props, propName, componentName) {
+                 *        var propValue = props[propName];
+                 *        if (propValue != null && typeof propValue !== 'string' &&
+                 *            !(propValue instanceof URI)) {
+                 *          return new Error(
+                 *            'Expected a string or an URI for ' + propName + ' in ' +
+                 *            componentName
+                 *          );
+                 *        }
+                 *      }
+                 *    },
+                 *    render: function() {...}
+                 *  });
+                 *
+                 * @internal
+                 */
+
+
+                var ANONYMOUS = '<<anonymous>>'; // Important!
+                // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
+
+                var ReactPropTypes = {
+                  array: createPrimitiveTypeChecker('array'),
+                  bigint: createPrimitiveTypeChecker('bigint'),
+                  bool: createPrimitiveTypeChecker('boolean'),
+                  func: createPrimitiveTypeChecker('function'),
+                  number: createPrimitiveTypeChecker('number'),
+                  object: createPrimitiveTypeChecker('object'),
+                  string: createPrimitiveTypeChecker('string'),
+                  symbol: createPrimitiveTypeChecker('symbol'),
+                  any: createAnyTypeChecker(),
+                  arrayOf: createArrayOfTypeChecker,
+                  element: createElementTypeChecker(),
+                  elementType: createElementTypeTypeChecker(),
+                  instanceOf: createInstanceTypeChecker,
+                  node: createNodeChecker(),
+                  objectOf: createObjectOfTypeChecker,
+                  oneOf: createEnumTypeChecker,
+                  oneOfType: createUnionTypeChecker,
+                  shape: createShapeTypeChecker,
+                  exact: createStrictShapeTypeChecker
+                };
+                /**
+                 * inlined Object.is polyfill to avoid requiring consumers ship their own
+                 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+                 */
+
+                /*eslint-disable no-self-compare*/
+
+                function is(x, y) {
+                  // SameValue algorithm
+                  if (x === y) {
+                    // Steps 1-5, 7-10
+                    // Steps 6.b-6.e: +0 != -0
+                    return x !== 0 || 1 / x === 1 / y;
+                  } else {
+                    // Step 6.a: NaN == NaN
+                    return x !== x && y !== y;
+                  }
+                }
+                /*eslint-enable no-self-compare*/
+
+                /**
+                 * We use an Error-like object for backward compatibility as people may call
+                 * PropTypes directly and inspect their output. However, we don't use real
+                 * Errors anymore. We don't inspect their stack anyway, and creating them
+                 * is prohibitively expensive if they are created too often, such as what
+                 * happens in oneOfType() for any type before the one that matched.
+                 */
+
+
+                function PropTypeError(message, data) {
+                  this.message = message;
+                  this.data = data && typeof data === 'object' ? data : {};
+                  this.stack = '';
+                } // Make `instanceof Error` still work for returned errors.
 
-          function createChainableTypeChecker(validate) {
-            function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
-              if (componentName = componentName || ANONYMOUS, propFullName = propFullName || propName, secret !== ReactPropTypesSecret) {
-                if (throwOnDirectAccess) {
-                  var err = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types");
-                  throw err.name = "Invariant Violation", err;
+
+                PropTypeError.prototype = Error.prototype;
+
+                function createChainableTypeChecker(validate) {
+                  {
+                    var manualPropTypeCallCache = {};
+                    var manualPropTypeWarningCount = 0;
+                  }
+
+                  function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+                    componentName = componentName || ANONYMOUS;
+                    propFullName = propFullName || propName;
+
+                    if (secret !== ReactPropTypesSecret) {
+                      if (throwOnDirectAccess) {
+                        // New behavior only for users of `prop-types` package
+                        var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use `PropTypes.checkPropTypes()` to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+                        err.name = 'Invariant Violation';
+                        throw err;
+                      } else if ( typeof console !== 'undefined') {
+                        // Old behavior for people using React.PropTypes
+                        var cacheKey = componentName + ':' + propName;
+
+                        if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
+                        manualPropTypeWarningCount < 3) {
+                          printWarning('You are manually calling a React.PropTypes validation ' + 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' + 'and will throw in the standalone `prop-types` package. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.');
+                          manualPropTypeCallCache[cacheKey] = true;
+                          manualPropTypeWarningCount++;
+                        }
+                      }
+                    }
+
+                    if (props[propName] == null) {
+                      if (isRequired) {
+                        if (props[propName] === null) {
+                          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+                        }
+
+                        return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+                      }
+
+                      return null;
+                    } else {
+                      return validate(props, propName, componentName, location, propFullName);
+                    }
+                  }
+
+                  var chainedCheckType = checkType.bind(null, false);
+                  chainedCheckType.isRequired = checkType.bind(null, true);
+                  return chainedCheckType;
                 }
 
-                if ("undefined" != typeof console) {
-                  var cacheKey = componentName + ":" + propName;
-                  !manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3 && (printWarning("You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."), manualPropTypeCallCache[cacheKey] = !0, manualPropTypeWarningCount++);
+                function createPrimitiveTypeChecker(expectedType) {
+                  function validate(props, propName, componentName, location, propFullName, secret) {
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+
+                    if (propType !== expectedType) {
+                      // `propValue` being instance of, say, date/regexp, pass the 'object'
+                      // check, but we can offer a more precise error message here rather than
+                      // 'of type `object`'.
+                      var preciseType = getPreciseType(propValue);
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'), {
+                        expectedType: expectedType
+                      });
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
                 }
-              }
 
-              return null == props[propName] ? isRequired ? new PropTypeError(null === props[propName] ? "The " + location + " `" + propFullName + "` is marked as required in `" + componentName + "`, but its value is `null`." : "The " + location + " `" + propFullName + "` is marked as required in `" + componentName + "`, but its value is `undefined`.") : null : validate(props, propName, componentName, location, propFullName);
-            }
+                function createAnyTypeChecker() {
+                  return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+                }
 
-            var manualPropTypeCallCache = {},
-                manualPropTypeWarningCount = 0,
-                chainedCheckType = checkType.bind(null, !1);
-            return chainedCheckType.isRequired = checkType.bind(null, !0), chainedCheckType;
-          }
+                function createArrayOfTypeChecker(typeChecker) {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    if (typeof typeChecker !== 'function') {
+                      return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+                    }
 
-          function createPrimitiveTypeChecker(expectedType) {
-            function validate(props, propName, componentName, location, propFullName, secret) {
-              var propValue = props[propName];
-              if (getPropType(propValue) !== expectedType) return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + getPreciseType(propValue) + "` supplied to `" + componentName + "`, expected `" + expectedType + "`.", {
-                expectedType: expectedType
-              });
-              return null;
-            }
+                    var propValue = props[propName];
 
-            return createChainableTypeChecker(validate);
-          }
+                    if (!Array.isArray(propValue)) {
+                      var propType = getPropType(propValue);
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+                    }
+
+                    for (var i = 0; i < propValue.length; i++) {
+                      var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+
+                      if (error instanceof Error) {
+                        return error;
+                      }
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createElementTypeChecker() {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+
+                    if (!isValidElement(propValue)) {
+                      var propType = getPropType(propValue);
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createElementTypeTypeChecker() {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+
+                    if (!ReactIs.isValidElementType(propValue)) {
+                      var propType = getPropType(propValue);
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createInstanceTypeChecker(expectedClass) {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    if (!(props[propName] instanceof expectedClass)) {
+                      var expectedClassName = expectedClass.name || ANONYMOUS;
+                      var actualClassName = getClassName(props[propName]);
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createEnumTypeChecker(expectedValues) {
+                  if (!Array.isArray(expectedValues)) {
+                    {
+                      if (arguments.length > 1) {
+                        printWarning('Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).');
+                      } else {
+                        printWarning('Invalid argument supplied to oneOf, expected an array.');
+                      }
+                    }
+
+                    return emptyFunctionThatReturnsNull;
+                  }
+
+                  function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+
+                    for (var i = 0; i < expectedValues.length; i++) {
+                      if (is(propValue, expectedValues[i])) {
+                        return null;
+                      }
+                    }
+
+                    var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+                      var type = getPreciseType(value);
+
+                      if (type === 'symbol') {
+                        return String(value);
+                      }
+
+                      return value;
+                    });
+                    return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createObjectOfTypeChecker(typeChecker) {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    if (typeof typeChecker !== 'function') {
+                      return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+                    }
+
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+
+                    if (propType !== 'object') {
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+                    }
+
+                    for (var key in propValue) {
+                      if (has(propValue, key)) {
+                        var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+                        if (error instanceof Error) {
+                          return error;
+                        }
+                      }
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createUnionTypeChecker(arrayOfTypeCheckers) {
+                  if (!Array.isArray(arrayOfTypeCheckers)) {
+                     printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') ;
+                    return emptyFunctionThatReturnsNull;
+                  }
+
+                  for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+                    var checker = arrayOfTypeCheckers[i];
+
+                    if (typeof checker !== 'function') {
+                      printWarning('Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
+                      return emptyFunctionThatReturnsNull;
+                    }
+                  }
+
+                  function validate(props, propName, componentName, location, propFullName) {
+                    var expectedTypes = [];
+
+                    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+                      var checker = arrayOfTypeCheckers[i];
+                      var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+
+                      if (checkerResult == null) {
+                        return null;
+                      }
+
+                      if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
+                        expectedTypes.push(checkerResult.data.expectedType);
+                      }
+                    }
+
+                    var expectedTypesMessage = expectedTypes.length > 0 ? ', expected one of type [' + expectedTypes.join(', ') + ']' : '';
+                    return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createNodeChecker() {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    if (!isNode(props[propName])) {
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
 
-          function createArrayOfTypeChecker(typeChecker) {
-            function validate(props, propName, componentName, location, propFullName) {
-              if ("function" != typeof typeChecker) return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
-              var propValue = props[propName];
+                function invalidValidatorError(componentName, location, propFullName, key, type) {
+                  return new PropTypeError((componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + type + '`.');
+                }
+
+                function createShapeTypeChecker(shapeTypes) {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+
+                    if (propType !== 'object') {
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+                    }
+
+                    for (var key in shapeTypes) {
+                      var checker = shapeTypes[key];
+
+                      if (typeof checker !== 'function') {
+                        return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+                      }
+
+                      var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+                      if (error) {
+                        return error;
+                      }
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function createStrictShapeTypeChecker(shapeTypes) {
+                  function validate(props, propName, componentName, location, propFullName) {
+                    var propValue = props[propName];
+                    var propType = getPropType(propValue);
+
+                    if (propType !== 'object') {
+                      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+                    } // We need to check all keys in case some are required but missing from props.
+
+
+                    var allKeys = assign({}, props[propName], shapeTypes);
+
+                    for (var key in allKeys) {
+                      var checker = shapeTypes[key];
+
+                      if (has(shapeTypes, key) && typeof checker !== 'function') {
+                        return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+                      }
+
+                      if (!checker) {
+                        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + JSON.stringify(props[propName], null, '  ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  '));
+                      }
+
+                      var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+                      if (error) {
+                        return error;
+                      }
+                    }
+
+                    return null;
+                  }
+
+                  return createChainableTypeChecker(validate);
+                }
+
+                function isNode(propValue) {
+                  switch (typeof propValue) {
+                    case 'number':
+                    case 'string':
+                    case 'undefined':
+                      return true;
+
+                    case 'boolean':
+                      return !propValue;
+
+                    case 'object':
+                      if (Array.isArray(propValue)) {
+                        return propValue.every(isNode);
+                      }
+
+                      if (propValue === null || isValidElement(propValue)) {
+                        return true;
+                      }
+
+                      var iteratorFn = getIteratorFn(propValue);
+
+                      if (iteratorFn) {
+                        var iterator = iteratorFn.call(propValue);
+                        var step;
+
+                        if (iteratorFn !== propValue.entries) {
+                          while (!(step = iterator.next()).done) {
+                            if (!isNode(step.value)) {
+                              return false;
+                            }
+                          }
+                        } else {
+                          // Iterator will provide entry [k,v] tuples rather than values.
+                          while (!(step = iterator.next()).done) {
+                            var entry = step.value;
+
+                            if (entry) {
+                              if (!isNode(entry[1])) {
+                                return false;
+                              }
+                            }
+                          }
+                        }
+                      } else {
+                        return false;
+                      }
+
+                      return true;
+
+                    default:
+                      return false;
+                  }
+                }
+
+                function isSymbol(propType, propValue) {
+                  // Native Symbol.
+                  if (propType === 'symbol') {
+                    return true;
+                  } // falsy value can't be a Symbol
+
+
+                  if (!propValue) {
+                    return false;
+                  } // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+
+
+                  if (propValue['@@toStringTag'] === 'Symbol') {
+                    return true;
+                  } // Fallback for non-spec compliant Symbols which are polyfilled.
+
+
+                  if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+                    return true;
+                  }
+
+                  return false;
+                } // Equivalent of `typeof` but with special handling for array and regexp.
+
+
+                function getPropType(propValue) {
+                  var propType = typeof propValue;
+
+                  if (Array.isArray(propValue)) {
+                    return 'array';
+                  }
+
+                  if (propValue instanceof RegExp) {
+                    // Old webkits (at least until Android 4.0) return 'function' rather than
+                    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+                    // passes PropTypes.object.
+                    return 'object';
+                  }
+
+                  if (isSymbol(propType, propValue)) {
+                    return 'symbol';
+                  }
+
+                  return propType;
+                } // This handles more types than `getPropType`. Only used for error messages.
+                // See `createPrimitiveTypeChecker`.
+
+
+                function getPreciseType(propValue) {
+                  if (typeof propValue === 'undefined' || propValue === null) {
+                    return '' + propValue;
+                  }
+
+                  var propType = getPropType(propValue);
+
+                  if (propType === 'object') {
+                    if (propValue instanceof Date) {
+                      return 'date';
+                    } else if (propValue instanceof RegExp) {
+                      return 'regexp';
+                    }
+                  }
+
+                  return propType;
+                } // Returns a string that is postfixed to a warning about an invalid type.
+                // For example, "undefined" or "of type array"
+
+
+                function getPostfixForTypeWarning(value) {
+                  var type = getPreciseType(value);
 
-              if (!Array.isArray(propValue)) {
-                return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + getPropType(propValue) + "` supplied to `" + componentName + "`, expected an array.");
+                  switch (type) {
+                    case 'array':
+                    case 'object':
+                      return 'an ' + type;
+
+                    case 'boolean':
+                    case 'date':
+                    case 'regexp':
+                      return 'a ' + type;
+
+                    default:
+                      return type;
+                  }
+                } // Returns class name of the object, if any.
+
+
+                function getClassName(propValue) {
+                  if (!propValue.constructor || !propValue.constructor.name) {
+                    return ANONYMOUS;
+                  }
+
+                  return propValue.constructor.name;
+                }
+
+                ReactPropTypes.checkPropTypes = checkPropTypes;
+                ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+                ReactPropTypes.PropTypes = ReactPropTypes;
+                return ReactPropTypes;
+              };
+              /***/
+
+            },
+
+            /***/
+            "./node_modules/prop-types/index.js":
+            /*!******************************************!*\
+              !*** ./node_modules/prop-types/index.js ***!
+              \******************************************/
+
+            /***/
+            (module, __unused_webpack_exports, __webpack_require__) => {
+              /**
+               * Copyright (c) 2013-present, Facebook, Inc.
+               *
+               * This source code is licensed under the MIT license found in the
+               * LICENSE file in the root directory of this source tree.
+               */
+              {
+                var ReactIs = __webpack_require__(
+                /*! react-is */
+                "./node_modules/react-is/index.js"); // By explicitly using `prop-types` you are opting into new development behavior.
+                // http://fb.me/prop-types-in-prod
+
+
+                var throwOnDirectAccess = true;
+                module.exports = __webpack_require__(
+                /*! ./factoryWithTypeCheckers */
+                "./node_modules/prop-types/factoryWithTypeCheckers.js")(ReactIs.isElement, throwOnDirectAccess);
               }
+              /***/
+
+            },
+
+            /***/
+            "./node_modules/prop-types/lib/ReactPropTypesSecret.js":
+            /*!*************************************************************!*\
+              !*** ./node_modules/prop-types/lib/ReactPropTypesSecret.js ***!
+              \*************************************************************/
+
+            /***/
+            module => {
+              /**
+               * Copyright (c) 2013-present, Facebook, Inc.
+               *
+               * This source code is licensed under the MIT license found in the
+               * LICENSE file in the root directory of this source tree.
+               */
+
+              var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+              module.exports = ReactPropTypesSecret;
+              /***/
+            },
+
+            /***/
+            "./node_modules/prop-types/lib/has.js":
+            /*!********************************************!*\
+              !*** ./node_modules/prop-types/lib/has.js ***!
+              \********************************************/
+
+            /***/
+            module => {
+              module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
+              /***/
+            },
+
+            /***/
+            "./node_modules/react-is/cjs/react-is.development.js":
+            /*!***********************************************************!*\
+              !*** ./node_modules/react-is/cjs/react-is.development.js ***!
+              \***********************************************************/
+
+            /***/
+            (__unused_webpack_module, exports) => {
+              /** @license React v16.13.1
+               * react-is.development.js
+               *
+               * Copyright (c) Facebook, Inc. and its affiliates.
+               *
+               * This source code is licensed under the MIT license found in the
+               * LICENSE file in the root directory of this source tree.
+               */
+
+              {
+                (function () {
+                  // nor polyfill, then a plain number is used for performance.
+
+                  var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+                  var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+                  var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+                  var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+                  var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+                  var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+                  var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+                  var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+                  // (unstable) APIs that have been removed. Can we remove the symbols?
+
+                  var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+                  var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+                  var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+                  var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+                  var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+                  var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+                  var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+                  var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+                  var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+                  var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+                  var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+                  function isValidElementType(type) {
+                    return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+                    type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+                  }
+
+                  function typeOf(object) {
+                    if (typeof object === 'object' && object !== null) {
+                      var $$typeof = object.$$typeof;
+
+                      switch ($$typeof) {
+                        case REACT_ELEMENT_TYPE:
+                          var type = object.type;
+
+                          switch (type) {
+                            case REACT_ASYNC_MODE_TYPE:
+                            case REACT_CONCURRENT_MODE_TYPE:
+                            case REACT_FRAGMENT_TYPE:
+                            case REACT_PROFILER_TYPE:
+                            case REACT_STRICT_MODE_TYPE:
+                            case REACT_SUSPENSE_TYPE:
+                              return type;
+
+                            default:
+                              var $$typeofType = type && type.$$typeof;
+
+                              switch ($$typeofType) {
+                                case REACT_CONTEXT_TYPE:
+                                case REACT_FORWARD_REF_TYPE:
+                                case REACT_LAZY_TYPE:
+                                case REACT_MEMO_TYPE:
+                                case REACT_PROVIDER_TYPE:
+                                  return $$typeofType;
+
+                                default:
+                                  return $$typeof;
+                              }
+
+                          }
+
+                        case REACT_PORTAL_TYPE:
+                          return $$typeof;
+                      }
+                    }
+
+                    return undefined;
+                  } // AsyncMode is deprecated along with isAsyncMode
+
+
+                  var AsyncMode = REACT_ASYNC_MODE_TYPE;
+                  var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+                  var ContextConsumer = REACT_CONTEXT_TYPE;
+                  var ContextProvider = REACT_PROVIDER_TYPE;
+                  var Element = REACT_ELEMENT_TYPE;
+                  var ForwardRef = REACT_FORWARD_REF_TYPE;
+                  var Fragment = REACT_FRAGMENT_TYPE;
+                  var Lazy = REACT_LAZY_TYPE;
+                  var Memo = REACT_MEMO_TYPE;
+                  var Portal = REACT_PORTAL_TYPE;
+                  var Profiler = REACT_PROFILER_TYPE;
+                  var StrictMode = REACT_STRICT_MODE_TYPE;
+                  var Suspense = REACT_SUSPENSE_TYPE;
+                  var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+                  function isAsyncMode(object) {
+                    {
+                      if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+                        hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+                        console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+                      }
+                    }
+                    return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+                  }
+
+                  function isConcurrentMode(object) {
+                    return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+                  }
+
+                  function isContextConsumer(object) {
+                    return typeOf(object) === REACT_CONTEXT_TYPE;
+                  }
+
+                  function isContextProvider(object) {
+                    return typeOf(object) === REACT_PROVIDER_TYPE;
+                  }
+
+                  function isElement(object) {
+                    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+                  }
+
+                  function isForwardRef(object) {
+                    return typeOf(object) === REACT_FORWARD_REF_TYPE;
+                  }
+
+                  function isFragment(object) {
+                    return typeOf(object) === REACT_FRAGMENT_TYPE;
+                  }
+
+                  function isLazy(object) {
+                    return typeOf(object) === REACT_LAZY_TYPE;
+                  }
+
+                  function isMemo(object) {
+                    return typeOf(object) === REACT_MEMO_TYPE;
+                  }
 
-              for (var i = 0; i < propValue.length; i++) {
-                var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
-                if (error instanceof Error) return error;
+                  function isPortal(object) {
+                    return typeOf(object) === REACT_PORTAL_TYPE;
+                  }
+
+                  function isProfiler(object) {
+                    return typeOf(object) === REACT_PROFILER_TYPE;
+                  }
+
+                  function isStrictMode(object) {
+                    return typeOf(object) === REACT_STRICT_MODE_TYPE;
+                  }
+
+                  function isSuspense(object) {
+                    return typeOf(object) === REACT_SUSPENSE_TYPE;
+                  }
+
+                  exports.AsyncMode = AsyncMode;
+                  exports.ConcurrentMode = ConcurrentMode;
+                  exports.ContextConsumer = ContextConsumer;
+                  exports.ContextProvider = ContextProvider;
+                  exports.Element = Element;
+                  exports.ForwardRef = ForwardRef;
+                  exports.Fragment = Fragment;
+                  exports.Lazy = Lazy;
+                  exports.Memo = Memo;
+                  exports.Portal = Portal;
+                  exports.Profiler = Profiler;
+                  exports.StrictMode = StrictMode;
+                  exports.Suspense = Suspense;
+                  exports.isAsyncMode = isAsyncMode;
+                  exports.isConcurrentMode = isConcurrentMode;
+                  exports.isContextConsumer = isContextConsumer;
+                  exports.isContextProvider = isContextProvider;
+                  exports.isElement = isElement;
+                  exports.isForwardRef = isForwardRef;
+                  exports.isFragment = isFragment;
+                  exports.isLazy = isLazy;
+                  exports.isMemo = isMemo;
+                  exports.isPortal = isPortal;
+                  exports.isProfiler = isProfiler;
+                  exports.isStrictMode = isStrictMode;
+                  exports.isSuspense = isSuspense;
+                  exports.isValidElementType = isValidElementType;
+                  exports.typeOf = typeOf;
+                })();
               }
+              /***/
 
-              return null;
-            }
+            },
 
-            return createChainableTypeChecker(validate);
-          }
+            /***/
+            "./node_modules/react-is/index.js":
+            /*!****************************************!*\
+              !*** ./node_modules/react-is/index.js ***!
+              \****************************************/
+
+            /***/
+            (module, __unused_webpack_exports, __webpack_require__) => {
 
-          function createInstanceTypeChecker(expectedClass) {
-            function validate(props, propName, componentName, location, propFullName) {
-              if (!(props[propName] instanceof expectedClass)) {
-                var expectedClassName = expectedClass.name || ANONYMOUS;
-                return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + getClassName(props[propName]) + "` supplied to `" + componentName + "`, expected instance of `" + expectedClassName + "`.");
+              {
+                module.exports = __webpack_require__(
+                /*! ./cjs/react-is.development.js */
+                "./node_modules/react-is/cjs/react-is.development.js");
               }
+              /***/
 
-              return null;
-            }
+            },
 
-            return createChainableTypeChecker(validate);
-          }
+            /***/
+            "./node_modules/shallow-equal/dist/index.esm.js":
+            /*!******************************************************!*\
+              !*** ./node_modules/shallow-equal/dist/index.esm.js ***!
+              \******************************************************/
+
+            /***/
+            (__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-          function createEnumTypeChecker(expectedValues) {
-            function validate(props, propName, componentName, location, propFullName) {
-              for (var propValue = props[propName], i = 0; i < expectedValues.length; i++) if (is(propValue, expectedValues[i])) return null;
+              __webpack_require__.r(__webpack_exports__);
+              /* harmony export */
+
+
+              __webpack_require__.d(__webpack_exports__, {
+                /* harmony export */
+                "shallowEqualArrays": () =>
+                /* binding */
+                shallowEqualArrays,
+
+                /* harmony export */
+                "shallowEqualObjects": () =>
+                /* binding */
+                shallowEqualObjects
+                /* harmony export */
 
-              var valuesString = JSON.stringify(expectedValues, function (key, value) {
-                return "symbol" === getPreciseType(value) ? String(value) : value;
               });
-              return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` supplied to `" + componentName + "`, expected one of " + valuesString + ".");
-            }
 
-            return Array.isArray(expectedValues) ? createChainableTypeChecker(validate) : (printWarning(arguments.length > 1 ? "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])." : "Invalid argument supplied to oneOf, expected an array."), emptyFunctionThatReturnsNull);
-          }
+              function shallowEqualObjects(objA, objB) {
+                if (objA === objB) {
+                  return true;
+                }
 
-          function createObjectOfTypeChecker(typeChecker) {
-            function validate(props, propName, componentName, location, propFullName) {
-              if ("function" != typeof typeChecker) return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
-              var propValue = props[propName],
-                  propType = getPropType(propValue);
-              if ("object" !== propType) return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` supplied to `" + componentName + "`, expected an object.");
+                if (!objA || !objB) {
+                  return false;
+                }
 
-              for (var key in propValue) if (has(propValue, key)) {
-                var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
-                if (error instanceof Error) return error;
-              }
+                var aKeys = Object.keys(objA);
+                var bKeys = Object.keys(objB);
+                var len = aKeys.length;
 
-              return null;
-            }
+                if (bKeys.length !== len) {
+                  return false;
+                }
 
-            return createChainableTypeChecker(validate);
-          }
+                for (var i = 0; i < len; i++) {
+                  var key = aKeys[i];
 
-          function createUnionTypeChecker(arrayOfTypeCheckers) {
-            function validate(props, propName, componentName, location, propFullName) {
-              for (var expectedTypes = [], i = 0; i < arrayOfTypeCheckers.length; i++) {
-                var checker = arrayOfTypeCheckers[i],
-                    checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
-                if (null == checkerResult) return null;
-                checkerResult.data && has(checkerResult.data, "expectedType") && expectedTypes.push(checkerResult.data.expectedType);
+                  if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
+                    return false;
+                  }
+                }
+
+                return true;
               }
 
-              return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to `" + componentName + "`" + (expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "") + ".");
-            }
+              function shallowEqualArrays(arrA, arrB) {
+                if (arrA === arrB) {
+                  return true;
+                }
 
-            if (!Array.isArray(arrayOfTypeCheckers)) return printWarning("Invalid argument supplied to oneOfType, expected an instance of array."), emptyFunctionThatReturnsNull;
+                if (!arrA || !arrB) {
+                  return false;
+                }
 
-            for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
-              var checker = arrayOfTypeCheckers[i];
-              if ("function" != typeof checker) return printWarning("Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."), emptyFunctionThatReturnsNull;
-            }
+                var len = arrA.length;
 
-            return createChainableTypeChecker(validate);
-          }
+                if (arrB.length !== len) {
+                  return false;
+                }
 
-          function invalidValidatorError(componentName, location, propFullName, key, type) {
-            return new PropTypeError((componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + "`.");
-          }
+                for (var i = 0; i < len; i++) {
+                  if (arrA[i] !== arrB[i]) {
+                    return false;
+                  }
+                }
 
-          function createShapeTypeChecker(shapeTypes) {
-            function validate(props, propName, componentName, location, propFullName) {
-              var propValue = props[propName],
-                  propType = getPropType(propValue);
-              if ("object" !== propType) return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` supplied to `" + componentName + "`, expected `object`.");
-
-              for (var key in shapeTypes) {
-                var checker = shapeTypes[key];
-                if ("function" != typeof checker) return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
-                var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
-                if (error) return error;
+                return true;
               }
+              /***/
 
-              return null;
-            }
+            },
 
-            return createChainableTypeChecker(validate);
-          }
+            /***/
+            "./src/Component.ts":
+            /*!**************************!*\
+              !*** ./src/Component.ts ***!
+              \**************************/
 
-          function createStrictShapeTypeChecker(shapeTypes) {
-            function validate(props, propName, componentName, location, propFullName) {
-              var propValue = props[propName],
-                  propType = getPropType(propValue);
-              if ("object" !== propType) return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` supplied to `" + componentName + "`, expected `object`.");
-              var allKeys = assign({}, props[propName], shapeTypes);
-
-              for (var key in allKeys) {
-                var checker = shapeTypes[key];
-                if (has(shapeTypes, key) && "function" != typeof checker) return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
-                if (!checker) return new PropTypeError("Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, "  ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, "  "));
-                var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
-                if (error) return error;
-              }
+            /***/
+            function (__unused_webpack_module, exports, __webpack_require__) {
 
-              return null;
-            }
+              var __rest = this && this.__rest || function (s, e) {
+                var t = {};
 
-            return createChainableTypeChecker(validate);
-          }
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+
+                if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                  if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+                }
+                return t;
+              };
+
+              var __importDefault = this && this.__importDefault || function (mod) {
+                return mod && mod.__esModule ? mod : {
+                  "default": mod
+                };
+              };
+
+              Object.defineProperty(exports, "__esModule", {
+                value: true
+              });
 
-          function isNode(propValue) {
-            switch (typeof propValue) {
-              case "number":
-              case "string":
-              case "undefined":
-                return !0;
+              var useMediaQuery_1 = __importDefault(__webpack_require__(
+              /*! ./useMediaQuery */
+              "./src/useMediaQuery.ts"));
 
-              case "boolean":
-                return !propValue;
+              var MediaQuery = function (_a) {
+                var children = _a.children,
+                    device = _a.device,
+                    onChange = _a.onChange,
+                    settings = __rest(_a, ["children", "device", "onChange"]);
 
-              case "object":
-                if (Array.isArray(propValue)) return propValue.every(isNode);
-                if (null === propValue || isValidElement(propValue)) return !0;
-                var iteratorFn = getIteratorFn(propValue);
-                if (!iteratorFn) return !1;
-                var step,
-                    iterator = iteratorFn.call(propValue);
-
-                if (iteratorFn !== propValue.entries) {
-                  for (; !(step = iterator.next()).done;) if (!isNode(step.value)) return !1;
-                } else for (; !(step = iterator.next()).done;) {
-                  var entry = step.value;
-                  if (entry && !isNode(entry[1])) return !1;
+                var matches = (0, useMediaQuery_1.default)(settings, device, onChange);
+
+                if (typeof children === 'function') {
+                  return children(matches);
                 }
 
-                return !0;
+                return matches ? children : null;
+              };
 
-              default:
-                return !1;
-            }
-          }
+              exports["default"] = MediaQuery;
+              /***/
+            },
 
-          function isSymbol(propType, propValue) {
-            return "symbol" === propType || !!propValue && ("Symbol" === propValue["@@toStringTag"] || "function" == typeof Symbol && propValue instanceof Symbol);
-          }
+            /***/
+            "./src/Context.ts":
+            /*!************************!*\
+              !*** ./src/Context.ts ***!
+              \************************/
 
-          function getPropType(propValue) {
-            var propType = typeof propValue;
-            return Array.isArray(propValue) ? "array" : propValue instanceof RegExp ? "object" : isSymbol(propType, propValue) ? "symbol" : propType;
-          }
+            /***/
+            (__unused_webpack_module, exports, __webpack_require__) => {
 
-          function getPreciseType(propValue) {
-            if (void 0 === propValue || null === propValue) return "" + propValue;
-            var propType = getPropType(propValue);
+              Object.defineProperty(exports, "__esModule", {
+                value: true
+              });
 
-            if ("object" === propType) {
-              if (propValue instanceof Date) return "date";
-              if (propValue instanceof RegExp) return "regexp";
-            }
+              var react_1 = __webpack_require__(
+              /*! react */
+              "react");
 
-            return propType;
-          }
+              var Context = (0, react_1.createContext)(undefined);
+              exports["default"] = Context;
+              /***/
+            },
 
-          function getPostfixForTypeWarning(value) {
-            var type = getPreciseType(value);
+            /***/
+            "./src/index.ts":
+            /*!**********************!*\
+              !*** ./src/index.ts ***!
+              \**********************/
 
-            switch (type) {
-              case "array":
-              case "object":
-                return "an " + type;
+            /***/
+            function (__unused_webpack_module, exports, __webpack_require__) {
+
+              var __importDefault = this && this.__importDefault || function (mod) {
+                return mod && mod.__esModule ? mod : {
+                  "default": mod
+                };
+              };
 
-              case "boolean":
-              case "date":
-              case "regexp":
-                return "a " + type;
+              Object.defineProperty(exports, "__esModule", {
+                value: true
+              });
+              exports.Context = exports.toQuery = exports.useMediaQuery = exports["default"] = void 0;
 
-              default:
-                return type;
-            }
-          }
+              var useMediaQuery_1 = __importDefault(__webpack_require__(
+              /*! ./useMediaQuery */
+              "./src/useMediaQuery.ts"));
 
-          function getClassName(propValue) {
-            return propValue.constructor && propValue.constructor.name ? propValue.constructor.name : ANONYMOUS;
-          }
+              exports.useMediaQuery = useMediaQuery_1.default;
+
+              var Component_1 = __importDefault(__webpack_require__(
+              /*! ./Component */
+              "./src/Component.ts"));
+
+              exports["default"] = Component_1.default;
+
+              var toQuery_1 = __importDefault(__webpack_require__(
+              /*! ./toQuery */
+              "./src/toQuery.ts"));
+
+              exports.toQuery = toQuery_1.default;
+
+              var Context_1 = __importDefault(__webpack_require__(
+              /*! ./Context */
+              "./src/Context.ts"));
+
+              exports.Context = Context_1.default;
+              /***/
+            },
+
+            /***/
+            "./src/mediaQuery.ts":
+            /*!***************************!*\
+              !*** ./src/mediaQuery.ts ***!
+              \***************************/
+
+            /***/
+            function (__unused_webpack_module, exports, __webpack_require__) {
+
+              var __assign = this && this.__assign || function () {
+                __assign = Object.assign || function (t) {
+                  for (var s, i = 1, n = arguments.length; i < n; i++) {
+                    s = arguments[i];
+
+                    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+                  }
+
+                  return t;
+                };
+
+                return __assign.apply(this, arguments);
+              };
+
+              var __rest = this && this.__rest || function (s, e) {
+                var t = {};
 
-          var ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator,
-              FAUX_ITERATOR_SYMBOL = "@@iterator",
-              ANONYMOUS = "<<anonymous>>",
-              ReactPropTypes = {
-            array: createPrimitiveTypeChecker("array"),
-            bigint: createPrimitiveTypeChecker("bigint"),
-            bool: createPrimitiveTypeChecker("boolean"),
-            func: createPrimitiveTypeChecker("function"),
-            number: createPrimitiveTypeChecker("number"),
-            object: createPrimitiveTypeChecker("object"),
-            string: createPrimitiveTypeChecker("string"),
-            symbol: createPrimitiveTypeChecker("symbol"),
-            any: function () {
-              return createChainableTypeChecker(emptyFunctionThatReturnsNull);
-            }(),
-            arrayOf: createArrayOfTypeChecker,
-            element: function () {
-              function validate(props, propName, componentName, location, propFullName) {
-                var propValue = props[propName];
-
-                if (!isValidElement(propValue)) {
-                  return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + getPropType(propValue) + "` supplied to `" + componentName + "`, expected a single ReactElement.");
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+
+                if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                  if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
                 }
+                return t;
+              };
 
-                return null;
-              }
+              var __importDefault = this && this.__importDefault || function (mod) {
+                return mod && mod.__esModule ? mod : {
+                  "default": mod
+                };
+              };
+
+              Object.defineProperty(exports, "__esModule", {
+                value: true
+              });
+
+              var prop_types_1 = __importDefault(__webpack_require__(
+              /*! prop-types */
+              "./node_modules/prop-types/index.js"));
+
+              var stringOrNumber = prop_types_1.default.oneOfType([prop_types_1.default.string, prop_types_1.default.number]); // media types
+
+              var types = {
+                all: prop_types_1.default.bool,
+                grid: prop_types_1.default.bool,
+                aural: prop_types_1.default.bool,
+                braille: prop_types_1.default.bool,
+                handheld: prop_types_1.default.bool,
+                print: prop_types_1.default.bool,
+                projection: prop_types_1.default.bool,
+                screen: prop_types_1.default.bool,
+                tty: prop_types_1.default.bool,
+                tv: prop_types_1.default.bool,
+                embossed: prop_types_1.default.bool
+              }; // properties that match media queries
+
+              var matchers = {
+                orientation: prop_types_1.default.oneOf(['portrait', 'landscape']),
+                scan: prop_types_1.default.oneOf(['progressive', 'interlace']),
+                aspectRatio: prop_types_1.default.string,
+                deviceAspectRatio: prop_types_1.default.string,
+                height: stringOrNumber,
+                deviceHeight: stringOrNumber,
+                width: stringOrNumber,
+                deviceWidth: stringOrNumber,
+                color: prop_types_1.default.bool,
+                colorIndex: prop_types_1.default.bool,
+                monochrome: prop_types_1.default.bool,
+                resolution: stringOrNumber,
+                type: Object.keys(types)
+              }; // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+              var featureMatchers = __rest(matchers // media features
+              , ["type"]); // media features
+
+
+              var features = __assign({
+                minAspectRatio: prop_types_1.default.string,
+                maxAspectRatio: prop_types_1.default.string,
+                minDeviceAspectRatio: prop_types_1.default.string,
+                maxDeviceAspectRatio: prop_types_1.default.string,
+                minHeight: stringOrNumber,
+                maxHeight: stringOrNumber,
+                minDeviceHeight: stringOrNumber,
+                maxDeviceHeight: stringOrNumber,
+                minWidth: stringOrNumber,
+                maxWidth: stringOrNumber,
+                minDeviceWidth: stringOrNumber,
+                maxDeviceWidth: stringOrNumber,
+                minColor: prop_types_1.default.number,
+                maxColor: prop_types_1.default.number,
+                minColorIndex: prop_types_1.default.number,
+                maxColorIndex: prop_types_1.default.number,
+                minMonochrome: prop_types_1.default.number,
+                maxMonochrome: prop_types_1.default.number,
+                minResolution: stringOrNumber,
+                maxResolution: stringOrNumber
+              }, featureMatchers);
+
+              var all = __assign(__assign({}, types), features);
+
+              exports["default"] = {
+                all: all,
+                types: types,
+                matchers: matchers,
+                features: features
+              };
+              /***/
+            },
+
+            /***/
+            "./src/toQuery.ts":
+            /*!************************!*\
+              !*** ./src/toQuery.ts ***!
+              \************************/
+
+            /***/
+            function (__unused_webpack_module, exports, __webpack_require__) {
+
+              var __importDefault = this && this.__importDefault || function (mod) {
+                return mod && mod.__esModule ? mod : {
+                  "default": mod
+                };
+              };
+
+              Object.defineProperty(exports, "__esModule", {
+                value: true
+              });
+
+              var hyphenate_style_name_1 = __importDefault(__webpack_require__(
+              /*! hyphenate-style-name */
+              "./node_modules/hyphenate-style-name/index.js"));
 
-              return createChainableTypeChecker(validate);
-            }(),
-            elementType: function () {
-              function validate(props, propName, componentName, location, propFullName) {
-                var propValue = props[propName];
+              var mediaQuery_1 = __importDefault(__webpack_require__(
+              /*! ./mediaQuery */
+              "./src/mediaQuery.ts"));
 
-                if (!ReactIs.isValidElementType(propValue)) {
-                  return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + getPropType(propValue) + "` supplied to `" + componentName + "`, expected a single ReactElement type.");
+              var negate = function (cond) {
+                return "not ".concat(cond);
+              };
+
+              var keyVal = function (k, v) {
+                var realKey = (0, hyphenate_style_name_1.default)(k); // px shorthand
+
+                if (typeof v === 'number') {
+                  v = "".concat(v, "px");
                 }
 
-                return null;
-              }
+                if (v === true) {
+                  return realKey;
+                }
 
-              return createChainableTypeChecker(validate);
-            }(),
-            instanceOf: createInstanceTypeChecker,
-            node: function () {
-              function validate(props, propName, componentName, location, propFullName) {
-                return isNode(props[propName]) ? null : new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to `" + componentName + "`, expected a ReactNode.");
-              }
+                if (v === false) {
+                  return negate(realKey);
+                }
+
+                return "(".concat(realKey, ": ").concat(v, ")");
+              };
+
+              var join = function (conds) {
+                return conds.join(' and ');
+              };
+
+              var toQuery = function (obj) {
+                var rules = [];
+                Object.keys(mediaQuery_1.default.all).forEach(function (k) {
+                  var v = obj[k];
+
+                  if (v != null) {
+                    rules.push(keyVal(k, v));
+                  }
+                });
+                return join(rules);
+              };
+
+              exports["default"] = toQuery;
+              /***/
+            },
+
+            /***/
+            "./src/useMediaQuery.ts":
+            /*!******************************!*\
+              !*** ./src/useMediaQuery.ts ***!
+              \******************************/
+
+            /***/
+            function (__unused_webpack_module, exports, __webpack_require__) {
+
+              var __importDefault = this && this.__importDefault || function (mod) {
+                return mod && mod.__esModule ? mod : {
+                  "default": mod
+                };
+              };
+
+              Object.defineProperty(exports, "__esModule", {
+                value: true
+              });
+
+              var react_1 = __webpack_require__(
+              /*! react */
+              "react");
+
+              var matchmediaquery_1 = __importDefault(__webpack_require__(
+              /*! matchmediaquery */
+              "./node_modules/matchmediaquery/index.js"));
+
+              var hyphenate_style_name_1 = __importDefault(__webpack_require__(
+              /*! hyphenate-style-name */
+              "./node_modules/hyphenate-style-name/index.js"));
+
+              var shallow_equal_1 = __webpack_require__(
+              /*! shallow-equal */
+              "./node_modules/shallow-equal/dist/index.esm.js");
+
+              var toQuery_1 = __importDefault(__webpack_require__(
+              /*! ./toQuery */
+              "./src/toQuery.ts"));
+
+              var Context_1 = __importDefault(__webpack_require__(
+              /*! ./Context */
+              "./src/Context.ts"));
+
+              var makeQuery = function (settings) {
+                return settings.query || (0, toQuery_1.default)(settings);
+              };
+
+              var hyphenateKeys = function (obj) {
+                if (!obj) return undefined;
+                var keys = Object.keys(obj);
+                return keys.reduce(function (result, key) {
+                  result[(0, hyphenate_style_name_1.default)(key)] = obj[key];
+                  return result;
+                }, {});
+              };
+
+              var useIsUpdate = function () {
+                var ref = (0, react_1.useRef)(false);
+                (0, react_1.useEffect)(function () {
+                  ref.current = true;
+                }, []);
+                return ref.current;
+              };
+
+              var useDevice = function (deviceFromProps) {
+                var deviceFromContext = (0, react_1.useContext)(Context_1.default);
+
+                var getDevice = function () {
+                  return hyphenateKeys(deviceFromProps) || hyphenateKeys(deviceFromContext);
+                };
+
+                var _a = (0, react_1.useState)(getDevice),
+                    device = _a[0],
+                    setDevice = _a[1];
+
+                (0, react_1.useEffect)(function () {
+                  var newDevice = getDevice();
+
+                  if (!(0, shallow_equal_1.shallowEqualObjects)(device, newDevice)) {
+                    setDevice(newDevice);
+                  }
+                }, [deviceFromProps, deviceFromContext]);
+                return device;
+              };
+
+              var useQuery = function (settings) {
+                var getQuery = function () {
+                  return makeQuery(settings);
+                };
+
+                var _a = (0, react_1.useState)(getQuery),
+                    query = _a[0],
+                    setQuery = _a[1];
+
+                (0, react_1.useEffect)(function () {
+                  var newQuery = getQuery();
+
+                  if (query !== newQuery) {
+                    setQuery(newQuery);
+                  }
+                }, [settings]);
+                return query;
+              };
+
+              var useMatchMedia = function (query, device) {
+                var getMatchMedia = function () {
+                  return (0, matchmediaquery_1.default)(query, device || {}, !!device);
+                };
+
+                var _a = (0, react_1.useState)(getMatchMedia),
+                    mq = _a[0],
+                    setMq = _a[1];
+
+                var isUpdate = useIsUpdate();
+                (0, react_1.useEffect)(function () {
+                  if (isUpdate) {
+                    // skip on mounting, it has already been set
+                    var newMq_1 = getMatchMedia();
+                    setMq(newMq_1);
+                    return function () {
+                      if (newMq_1) {
+                        newMq_1.dispose();
+                      }
+                    };
+                  }
+                }, [query, device]);
+                return mq;
+              };
+
+              var useMatches = function (mediaQuery) {
+                var _a = (0, react_1.useState)(mediaQuery.matches),
+                    matches = _a[0],
+                    setMatches = _a[1];
+
+                (0, react_1.useEffect)(function () {
+                  var updateMatches = function (ev) {
+                    setMatches(ev.matches);
+                  };
+
+                  mediaQuery.addListener(updateMatches);
+                  setMatches(mediaQuery.matches);
+                  return function () {
+                    mediaQuery.removeListener(updateMatches);
+                  };
+                }, [mediaQuery]);
+                return matches;
+              };
+
+              var useMediaQuery = function (settings, device, onChange) {
+                var deviceSettings = useDevice(device);
+                var query = useQuery(settings);
+                if (!query) throw new Error('Invalid or missing MediaQuery!');
+                var mq = useMatchMedia(query, deviceSettings);
+                var matches = useMatches(mq);
+                var isUpdate = useIsUpdate();
+                (0, react_1.useEffect)(function () {
+                  if (isUpdate && onChange) {
+                    onChange(matches);
+                  }
+                }, [matches]);
+                (0, react_1.useEffect)(function () {
+                  return function () {
+                    if (mq) {
+                      mq.dispose();
+                    }
+                  };
+                }, []);
+                return matches;
+              };
+
+              exports["default"] = useMediaQuery;
+              /***/
+            },
+
+            /***/
+            "react":
+            /*!**************************************************************************************!*\
+              !*** external {"commonjs":"react","commonjs2":"react","amd":"react","root":"React"} ***!
+              \**************************************************************************************/
+
+            /***/
+            module => {
+
+              module.exports = __WEBPACK_EXTERNAL_MODULE_react__;
+              /***/
+            }
+            /******/
 
-              return createChainableTypeChecker(validate);
-            }(),
-            objectOf: createObjectOfTypeChecker,
-            oneOf: createEnumTypeChecker,
-            oneOfType: createUnionTypeChecker,
-            shape: createShapeTypeChecker,
-            exact: createStrictShapeTypeChecker
           };
-          return PropTypeError.prototype = Error.prototype, ReactPropTypes.checkPropTypes = checkPropTypes, ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache, ReactPropTypes.PropTypes = ReactPropTypes, ReactPropTypes;
-        };
-      }, function (module, exports, __webpack_require__) {
+          /************************************************************************/
 
-        function toObject(val) {
-          if (null === val || void 0 === val) throw new TypeError("Object.assign cannot be called with null or undefined");
-          return Object(val);
-        }
-        /*
-        object-assign
-        (c) Sindre Sorhus
-        @license MIT
-        */
+          /******/
+          // The module cache
 
+          /******/
 
-        var getOwnPropertySymbols = Object.getOwnPropertySymbols,
-            hasOwnProperty = Object.prototype.hasOwnProperty,
-            propIsEnumerable = Object.prototype.propertyIsEnumerable;
-        module.exports = function () {
-          try {
-            if (!Object.assign) return !1;
-            var test1 = new String("abc");
-            if (test1[5] = "de", "5" === Object.getOwnPropertyNames(test1)[0]) return !1;
-
-            for (var test2 = {}, i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i;
-
-            if ("0123456789" !== Object.getOwnPropertyNames(test2).map(function (n) {
-              return test2[n];
-            }).join("")) return !1;
-            var test3 = {};
-            return "abcdefghijklmnopqrst".split("").forEach(function (letter) {
-              test3[letter] = letter;
-            }), "abcdefghijklmnopqrst" === Object.keys(Object.assign({}, test3)).join("");
-          } catch (err) {
-            return !1;
-          }
-        }() ? Object.assign : function (target, source) {
-          for (var from, symbols, to = toObject(target), s = 1; s < arguments.length; s++) {
-            from = Object(arguments[s]);
+          var __webpack_module_cache__ = {};
+          /******/
 
-            for (var key in from) hasOwnProperty.call(from, key) && (to[key] = from[key]);
+          /******/
+          // The require function
 
-            if (getOwnPropertySymbols) {
-              symbols = getOwnPropertySymbols(from);
+          /******/
 
-              for (var i = 0; i < symbols.length; i++) propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]);
+          function __webpack_require__(moduleId) {
+            /******/
+            // Check if module is in cache
+
+            /******/
+            var cachedModule = __webpack_module_cache__[moduleId];
+            /******/
+
+            if (cachedModule !== undefined) {
+              /******/
+              return cachedModule.exports;
+              /******/
             }
+            /******/
+            // Create a new module (and put it into the cache)
+
+            /******/
+
+
+            var module = __webpack_module_cache__[moduleId] = {
+              /******/
+              // no module.id needed
+
+              /******/
+              // no module.loaded needed
+
+              /******/
+              exports: {}
+              /******/
+
+            };
+            /******/
+
+            /******/
+            // Execute the module function
+
+            /******/
+
+            __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+            /******/
+
+            /******/
+            // Return the exports of the module
+
+            /******/
+
+
+            return module.exports;
+            /******/
           }
+          /******/
 
-          return to;
-        };
-      }, function (module, exports, __webpack_require__) {
+          /************************************************************************/
+
+          /******/
+
+          /* webpack/runtime/define property getters */
 
-        function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
-          for (var typeSpecName in typeSpecs) if (has(typeSpecs, typeSpecName)) {
-            var error;
+          /******/
+
+
+          (() => {
+            /******/
+            // define getter functions for harmony exports
+
+            /******/
+            __webpack_require__.d = (exports, definition) => {
+              /******/
+              for (var key in definition) {
+                /******/
+                if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+                  /******/
+                  Object.defineProperty(exports, key, {
+                    enumerable: true,
+                    get: definition[key]
+                  });
+                  /******/
+                }
+                /******/
 
-            try {
-              if ("function" != typeof typeSpecs[typeSpecName]) {
-                var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
-                throw err.name = "Invariant Violation", err;
               }
+              /******/
 
-              error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
-            } catch (ex) {
-              error = ex;
-            }
+            };
+            /******/
 
-            if (!error || error instanceof Error || printWarning((componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."), error instanceof Error && !(error.message in loggedTypeFailures)) {
-              loggedTypeFailures[error.message] = !0;
-              var stack = getStack ? getStack() : "";
-              printWarning("Failed " + location + " type: " + error.message + (null != stack ? stack : ""));
-            }
-          }
-        }
+          })();
+          /******/
 
-        var printWarning = function () {},
-            ReactPropTypesSecret = __webpack_require__(5),
-            loggedTypeFailures = {},
-            has = __webpack_require__(6);
+          /******/
 
-        printWarning = function (text) {
-          var message = "Warning: " + text;
-          "undefined" != typeof console && console.error(message);
+          /* webpack/runtime/hasOwnProperty shorthand */
 
-          try {
-            throw new Error(message);
-          } catch (x) {}
-        }, checkPropTypes.resetWarningCache = function () {
-          loggedTypeFailures = {};
-        }, module.exports = checkPropTypes;
-      }, function (module, exports, __webpack_require__) {
+          /******/
 
-        var __rest = this && this.__rest || function (s, e) {
-          var t = {};
 
-          for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0 && (t[p] = s[p]);
+          (() => {
+            /******/
+            __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+            /******/
 
-          if (null != s && "function" == typeof Object.getOwnPropertySymbols) for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]) && (t[p[i]] = s[p[i]]);
-          return t;
-        },
-            __importDefault = this && this.__importDefault || function (mod) {
-          return mod && mod.__esModule ? mod : {
-            default: mod
-          };
-        };
+          })();
+          /******/
 
-        Object.defineProperty(exports, "__esModule", {
-          value: !0
-        });
+          /******/
 
-        var useMediaQuery_1 = __importDefault(__webpack_require__(0)),
-            MediaQuery = function (_a) {
-          var children = _a.children,
-              device = _a.device,
-              onChange = _a.onChange,
-              settings = __rest(_a, ["children", "device", "onChange"]),
-              matches = (0, useMediaQuery_1.default)(settings, device, onChange);
+          /* webpack/runtime/make namespace object */
 
-          return "function" == typeof children ? children(matches) : matches ? children : null;
-        };
+          /******/
 
-        exports.default = MediaQuery;
-      }]);
+
+          (() => {
+            /******/
+            // define __esModule on exports
+
+            /******/
+            __webpack_require__.r = exports => {
+              /******/
+              if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+                /******/
+                Object.defineProperty(exports, Symbol.toStringTag, {
+                  value: 'Module'
+                });
+                /******/
+              }
+              /******/
+
+
+              Object.defineProperty(exports, '__esModule', {
+                value: true
+              });
+              /******/
+            };
+            /******/
+
+          })();
+          /******/
+
+          /************************************************************************/
+
+          /******/
+
+          /******/
+          // startup
+
+          /******/
+          // Load entry module and return exports
+
+          /******/
+          // This entry module is referenced by other modules so it can't be inlined
+
+          /******/
+
+
+          var __webpack_exports__ = __webpack_require__("./src/index.ts");
+          /******/
+
+          /******/
+
+
+          return __webpack_exports__;
+          /******/
+        })()
+      );
     });
   });
   var reactResponsive$1 = /*@__PURE__*/unwrapExports(reactResponsive);