react-cookie-consent/build/index.js

module.exports = /******/ (function (modules) {
  // webpackBootstrap
  /******/ // The module cache
  /******/ var installedModules = {}; // The require function
  /******/
  /******/ /******/ function __webpack_require__(moduleId) {
    /******/
    /******/ // Check if module is in cache
    /******/ if (installedModules[moduleId]) {
      /******/ return installedModules[moduleId].exports;
      /******/
    } // Create a new module (and put it into the cache)
    /******/ /******/ var module = (installedModules[moduleId] = {
      /******/ i: moduleId,
      /******/ l: false,
      /******/ exports: {},
      /******/
    }); // Execute the module function
    /******/
    /******/ /******/ modules[moduleId].call(
      module.exports,
      module,
      module.exports,
      __webpack_require__
    ); // Flag the module as loaded
    /******/
    /******/ /******/ module.l = true; // Return the exports of the module
    /******/
    /******/ /******/ return module.exports;
    /******/
  } // expose the modules object (__webpack_modules__)
  /******/
  /******/
  /******/ /******/ __webpack_require__.m = modules; // expose the module cache
  /******/
  /******/ /******/ __webpack_require__.c = installedModules; // identity function for calling harmony imports with the correct context
  /******/
  /******/ /******/ __webpack_require__.i = function (value) {
    return value;
  }; // define getter function for harmony exports
  /******/
  /******/ /******/ __webpack_require__.d = function (exports, name, getter) {
    /******/ if (!__webpack_require__.o(exports, name)) {
      /******/ Object.defineProperty(exports, name, {
        /******/ configurable: false,
        /******/ enumerable: true,
        /******/ get: getter,
        /******/
      });
      /******/
    }
    /******/
  }; // getDefaultExport function for compatibility with non-harmony modules
  /******/
  /******/ /******/ __webpack_require__.n = function (module) {
    /******/ var getter =
      module && module.__esModule
        ? /******/ function getDefault() {
            return module["default"];
          }
        : /******/ function getModuleExports() {
            return module;
          };
    /******/ __webpack_require__.d(getter, "a", getter);
    /******/ return getter;
    /******/
  }; // Object.prototype.hasOwnProperty.call
  /******/
  /******/ /******/ __webpack_require__.o = function (object, property) {
    return Object.prototype.hasOwnProperty.call(object, property);
  }; // __webpack_public_path__
  /******/
  /******/ /******/ __webpack_require__.p = ""; // Load entry module and return exports
  /******/
  /******/ /******/ return __webpack_require__((__webpack_require__.s = 6));
  /******/
})(
  /************************************************************************/
  /******/ [
    /* 0 */
    /***/ function (module, exports) {
      // shim for using process in browser
      var process = (module.exports = {});

      // cached from whatever global is present so that test runners that stub it
      // don't break things.  But we need to wrap it in a try catch in case it is
      // wrapped in strict mode code which doesn't define any globals.  It's inside a
      // function because try/catches deoptimize in certain engines.

      var cachedSetTimeout;
      var cachedClearTimeout;

      function defaultSetTimout() {
        throw new Error("setTimeout has not been defined");
      }
      function defaultClearTimeout() {
        throw new Error("clearTimeout has not been defined");
      }
      (function () {
        try {
          if (typeof setTimeout === "function") {
            cachedSetTimeout = setTimeout;
          } else {
            cachedSetTimeout = defaultSetTimout;
          }
        } catch (e) {
          cachedSetTimeout = defaultSetTimout;
        }
        try {
          if (typeof clearTimeout === "function") {
            cachedClearTimeout = clearTimeout;
          } else {
            cachedClearTimeout = defaultClearTimeout;
          }
        } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
        }
      })();
      function runTimeout(fun) {
        if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
        }
        // if setTimeout wasn't available but was latter defined
        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
          }
        }
      }
      function runClearTimeout(marker) {
        if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
        }
        // if clearTimeout wasn't available but was latter defined
        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
          }
        }
      }
      var queue = [];
      var draining = false;
      var currentQueue;
      var queueIndex = -1;

      function cleanUpNextTick() {
        if (!draining || !currentQueue) {
          return;
        }
        draining = false;
        if (currentQueue.length) {
          queue = currentQueue.concat(queue);
        } else {
          queueIndex = -1;
        }
        if (queue.length) {
          drainQueue();
        }
      }

      function drainQueue() {
        if (draining) {
          return;
        }
        var timeout = runTimeout(cleanUpNextTick);
        draining = true;

        var len = queue.length;
        while (len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
            if (currentQueue) {
              currentQueue[queueIndex].run();
            }
          }
          queueIndex = -1;
          len = queue.length;
        }
        currentQueue = null;
        draining = false;
        runClearTimeout(timeout);
      }

      process.nextTick = function (fun) {
        var args = new Array(arguments.length - 1);
        if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
          }
        }
        queue.push(new Item(fun, args));
        if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
        }
      };

      // v8 likes predictible objects
      function Item(fun, array) {
        this.fun = fun;
        this.array = array;
      }
      Item.prototype.run = function () {
        this.fun.apply(null, this.array);
      };
      process.title = "browser";
      process.browser = true;
      process.env = {};
      process.argv = [];
      process.version = ""; // empty string to avoid regexp issues
      process.versions = {};

      function noop() {}

      process.on = noop;
      process.addListener = noop;
      process.once = noop;
      process.off = noop;
      process.removeListener = noop;
      process.removeAllListeners = noop;
      process.emit = noop;
      process.prependListener = noop;
      process.prependOnceListener = noop;

      process.listeners = function (name) {
        return [];
      };

      process.binding = function (name) {
        throw new Error("process.binding is not supported");
      };

      process.cwd = function () {
        return "/";
      };
      process.chdir = function (dir) {
        throw new Error("process.chdir is not supported");
      };
      process.umask = function () {
        return 0;
      };

      /***/
    },
    /* 1 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /**
       * 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;

      /***/
    },
    /* 2 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /* WEBPACK VAR INJECTION */ (function (process) {
        if (process.env.NODE_ENV === "production") {
          module.exports = __webpack_require__(12);
        } else {
          module.exports = __webpack_require__(11);
        }

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(0)));

      /***/
    },
    /* 3 */
    /***/ function (module, exports, __webpack_require__) {
      var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;
      /*!
       * JavaScript Cookie v2.2.1
       * https://github.com/js-cookie/js-cookie
       *
       * Copyright 2006, 2015 Klaus Hartl & Fagner Brack
       * Released under the MIT license
       */
      (function (factory) {
        var registeredInModuleLoader;
        if (true) {
          !((__WEBPACK_AMD_DEFINE_FACTORY__ = factory),
          (__WEBPACK_AMD_DEFINE_RESULT__ =
            typeof __WEBPACK_AMD_DEFINE_FACTORY__ === "function"
              ? __WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)
              : __WEBPACK_AMD_DEFINE_FACTORY__),
          __WEBPACK_AMD_DEFINE_RESULT__ !== undefined &&
            (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
          registeredInModuleLoader = true;
        }
        if (true) {
          module.exports = factory();
          registeredInModuleLoader = true;
        }
        if (!registeredInModuleLoader) {
          var OldCookies = window.Cookies;
          var api = (window.Cookies = factory());
          api.noConflict = function () {
            window.Cookies = OldCookies;
            return api;
          };
        }
      })(function () {
        function extend() {
          var i = 0;
          var result = {};
          for (; i < arguments.length; i++) {
            var attributes = arguments[i];
            for (var key in attributes) {
              result[key] = attributes[key];
            }
          }
          return result;
        }

        function decode(s) {
          return s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent);
        }

        function init(converter) {
          function api() {}

          function set(key, value, attributes) {
            if (typeof document === "undefined") {
              return;
            }

            attributes = extend(
              {
                path: "/",
              },
              api.defaults,
              attributes
            );

            if (typeof attributes.expires === "number") {
              attributes.expires = new Date(new Date() * 1 + attributes.expires * 864e5);
            }

            // We're using "expires" because "max-age" is not supported by IE
            attributes.expires = attributes.expires ? attributes.expires.toUTCString() : "";

            try {
              var result = JSON.stringify(value);
              if (/^[\{\[]/.test(result)) {
                value = result;
              }
            } catch (e) {}

            value = converter.write
              ? converter.write(value, key)
              : encodeURIComponent(String(value)).replace(
                  /%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g,
                  decodeURIComponent
                );

            key = encodeURIComponent(String(key))
              .replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent)
              .replace(/[\(\)]/g, escape);

            var stringifiedAttributes = "";
            for (var attributeName in attributes) {
              if (!attributes[attributeName]) {
                continue;
              }
              stringifiedAttributes += "; " + attributeName;
              if (attributes[attributeName] === true) {
                continue;
              }

              // Considers RFC 6265 section 5.2:
              // ...
              // 3.  If the remaining unparsed-attributes contains a %x3B (";")
              //     character:
              // Consume the characters of the unparsed-attributes up to,
              // not including, the first %x3B (";") character.
              // ...
              stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
            }

            return (document.cookie = key + "=" + value + stringifiedAttributes);
          }

          function get(key, json) {
            if (typeof document === "undefined") {
              return;
            }

            var jar = {};
            // To prevent the for loop in the first place assign an empty array
            // in case there are no cookies at all.
            var cookies = document.cookie ? document.cookie.split("; ") : [];
            var i = 0;

            for (; i < cookies.length; i++) {
              var parts = cookies[i].split("=");
              var cookie = parts.slice(1).join("=");

              if (!json && cookie.charAt(0) === '"') {
                cookie = cookie.slice(1, -1);
              }

              try {
                var name = decode(parts[0]);
                cookie = (converter.read || converter)(cookie, name) || decode(cookie);

                if (json) {
                  try {
                    cookie = JSON.parse(cookie);
                  } catch (e) {}
                }

                jar[name] = cookie;

                if (key === name) {
                  break;
                }
              } catch (e) {}
            }

            return key ? jar[key] : jar;
          }

          api.set = set;
          api.get = function (key) {
            return get(key, false /* read as raw */);
          };
          api.getJSON = function (key) {
            return get(key, true /* read as json */);
          };
          api.remove = function (key, attributes) {
            set(
              key,
              "",
              extend(attributes, {
                expires: -1,
              })
            );
          };

          api.defaults = {};

          api.withConverter = init;

          return api;
        }

        return init(function () {});
      });

      /***/
    },
    /* 4 */
    /***/ function (module, exports, __webpack_require__) {
      /* WEBPACK VAR INJECTION */ (function (process) {
        /**
         * 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.
         */

        if (process.env.NODE_ENV !== "production") {
          var ReactIs = __webpack_require__(2);

          // 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__(10)(ReactIs.isElement, throwOnDirectAccess);
        } else {
          // By explicitly using `prop-types` you are opting into new production behavior.
          // http://fb.me/prop-types-in-prod
          module.exports = __webpack_require__(9)();
        }

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(0)));

      /***/
    },
    /* 5 */
    /***/ function (module, exports) {
      module.exports = require("react");

      /***/
    },
    /* 6 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";

      Object.defineProperty(exports, "__esModule", {
        value: true,
      });
      exports.Cookies = exports.SAME_SITE_OPTIONS = exports.OPTIONS = undefined;

      var _extends =
        Object.assign ||
        function (target) {
          for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i];
            for (var key in source) {
              if (Object.prototype.hasOwnProperty.call(source, key)) {
                target[key] = source[key];
              }
            }
          }
          return target;
        };

      var _createClass = (function () {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }
        return function (Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      })();

      var _react = __webpack_require__(5);

      var _react2 = _interopRequireDefault(_react);

      var _propTypes = __webpack_require__(4);

      var _propTypes2 = _interopRequireDefault(_propTypes);

      var _jsCookie = __webpack_require__(3);

      var _jsCookie2 = _interopRequireDefault(_jsCookie);

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }

      function _objectWithoutProperties(obj, keys) {
        var target = {};
        for (var i in obj) {
          if (keys.indexOf(i) >= 0) continue;
          if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
          target[i] = obj[i];
        }
        return target;
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      function _possibleConstructorReturn(self, call) {
        if (!self) {
          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        }
        return call && (typeof call === "object" || typeof call === "function") ? call : self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== "function" && superClass !== null) {
          throw new TypeError(
            "Super expression must either be null or a function, not " + typeof superClass
          );
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: { value: subClass, enumerable: false, writable: true, configurable: true },
        });
        if (superClass)
          Object.setPrototypeOf
            ? Object.setPrototypeOf(subClass, superClass)
            : (subClass.__proto__ = superClass);
      }

      var OPTIONS = (exports.OPTIONS = {
        TOP: "top",
        BOTTOM: "bottom",
        NONE: "none",
      });

      var SAME_SITE_OPTIONS = (exports.SAME_SITE_OPTIONS = {
        STRICT: "strict",
        LAX: "lax",
        NONE: "none",
      });

      var CookieConsent = (function (_Component) {
        _inherits(CookieConsent, _Component);

        function CookieConsent(props) {
          _classCallCheck(this, CookieConsent);

          var _this = _possibleConstructorReturn(
            this,
            (CookieConsent.__proto__ || Object.getPrototypeOf(CookieConsent)).call(this, props)
          );

          _this.accept.bind(_this);

          _this.state = {
            visible: false,
            style: {
              alignItems: "baseline",
              background: "#353535",
              color: "white",
              display: "flex",
              flexWrap: "wrap",
              justifyContent: "space-between",
              left: "0",
              position: "fixed",
              width: "100%",
              zIndex: "999",
            },
            buttonStyle: {
              background: "#ffd42d",
              border: "0",
              borderRadius: "0px",
              boxShadow: "none",
              color: "black",
              cursor: "pointer",
              flex: "0 0 auto",
              padding: "5px 10px",
              margin: "15px",
            },
            declineButtonStyle: {
              background: "#c12a2a",
              border: "0",
              borderRadius: "0px",
              boxShadow: "none",
              color: "#e5e5e5",
              cursor: "pointer",
              flex: "0 0 auto",
              padding: "5px 10px",
              margin: "15px",
            },
            contentStyle: {
              flex: "1 0 300px",
              margin: "15px",
            },
            overlayStyle: {
              position: "absolute",
              left: 0,
              top: 0,
              width: "100%",
              height: "100%",
              zIndex: "999",
              backgroundColor: "rgba(0,0,0,0.3)",
            },
          };

          _this.handleScroll = _this.handleScroll.bind(_this);
          return _this;
        }

        _createClass(CookieConsent, [
          {
            key: "componentDidMount",
            value: function componentDidMount() {
              var debug = this.props.debug;

              // if cookie undefined or debug

              if (this.getCookieValue() === undefined || debug) {
                this.setState({ visible: true });

                // if acceptOnScroll is set to true and (cookie is undefined or debug is set to true), add a listener.
                if (this.props.acceptOnScroll) {
                  window.addEventListener("scroll", this.handleScroll, { passive: true });
                }
              }
            },
          },
          {
            key: "componentWillUnmount",
            value: function componentWillUnmount() {
              // remove listener if still set
              window.removeEventListener("scroll", this.handleScroll);
            },

            /**
             * checks whether scroll has exceeded set amount and fire accept if so.
             */
          },
          {
            key: "handleScroll",
            value: function handleScroll() {
              // (top / height) - height * 100
              var rootNode = document.documentElement,
                body = document.body,
                top = "scrollTop",
                height = "scrollHeight";

              var percentage =
                ((rootNode[top] || body[top]) /
                  ((rootNode[height] || body[height]) - rootNode.clientHeight)) *
                100;

              if (percentage > this.props.acceptOnScrollPercentage) {
                this.accept({ acceptedByScrolling: true });
              }
            },

            /**
             * Set a persistent accept cookie
             */
          },
          {
            key: "accept",
            value: function accept(_ref) {
              var _ref$acceptedByScroll = _ref.acceptedByScrolling,
                acceptedByScrolling =
                  _ref$acceptedByScroll === undefined ? false : _ref$acceptedByScroll;
              var _props = this.props,
                cookieName = _props.cookieName,
                cookieValue = _props.cookieValue,
                hideOnAccept = _props.hideOnAccept,
                onAccept = _props.onAccept;

              // fire onAccept

              onAccept({ acceptedByScrolling: acceptedByScrolling });

              // remove listener if set
              window.removeEventListener("scroll", this.handleScroll);

              this.setCookie(cookieName, cookieValue);

              if (hideOnAccept) {
                this.setState({ visible: false });
              }
            },

            /**
             * Set a persistent decline cookie
             */
          },
          {
            key: "decline",
            value: function decline() {
              var _props2 = this.props,
                cookieName = _props2.cookieName,
                declineCookieValue = _props2.declineCookieValue,
                expires = _props2.expires,
                hideOnDecline = _props2.hideOnDecline,
                onDecline = _props2.onDecline,
                extraCookieOptions = _props2.extraCookieOptions,
                setDeclineCookie = _props2.setDeclineCookie;

              // fire onDecline

              onDecline();

              // remove listener if set
              window.removeEventListener("scroll", this.handleScroll);

              if (setDeclineCookie) {
                this.setCookie(cookieName, declineCookieValue);
              }

              if (hideOnDecline) {
                this.setState({ visible: false });
              }
            },

            /**
             * Get the legacy cookie name by the regular cookie name
             * @param {string} name of cookie to get
             */
          },
          {
            key: "getLegacyCookieName",
            value: function getLegacyCookieName(name) {
              return name + "-legacy";
            },

            /**
             * Function to set the consent cookie based on the provided variables
             * Sets two cookies to handle incompatible browsers, more details:
             * https://web.dev/samesite-cookie-recipes/#handling-incompatible-clients
             */
          },
          {
            key: "setCookie",
            value: function setCookie(cookieName, cookieValue) {
              var _props3 = this.props,
                extraCookieOptions = _props3.extraCookieOptions,
                expires = _props3.expires,
                sameSite = _props3.sameSite;
              var cookieSecurity = this.props.cookieSecurity;

              if (cookieSecurity === undefined) {
                cookieSecurity = location ? location.protocol === "https:" : true;
              }

              var cookieOptions = _extends({ expires: expires }, extraCookieOptions, {
                sameSite: sameSite,
                secure: cookieSecurity,
              });

              // Fallback for older browsers where can not set SameSite=None, SEE: https://web.dev/samesite-cookie-recipes/#handling-incompatible-clients
              if (sameSite === SAME_SITE_OPTIONS.NONE) {
                _jsCookie2.default.set(
                  this.getLegacyCookieName(cookieName),
                  cookieValue,
                  cookieOptions
                );
              }

              // set the regular cookie
              _jsCookie2.default.set(cookieName, cookieValue, cookieOptions);
            },

            /**
             * Returns the value of the consent cookie
             * Retrieves the regular value first and if not found the legacy one according
             * to: https://web.dev/samesite-cookie-recipes/#handling-incompatible-clients
             */
          },
          {
            key: "getCookieValue",
            value: function getCookieValue() {
              var cookieName = this.props.cookieName;

              var cookieValue = _jsCookie2.default.get(cookieName);

              // if the cookieValue is undefined check for the legacy cookie
              if (cookieValue === undefined) {
                cookieValue = _jsCookie2.default.get(this.getLegacyCookieName(cookieName));
              }
              return cookieValue;
            },
          },
          {
            key: "render",
            value: function render() {
              var _this2 = this;

              // If the bar shouldn't be visible don't render anything.
              if (!this.state.visible) {
                return null;
              }

              var _props4 = this.props,
                location = _props4.location,
                style = _props4.style,
                buttonStyle = _props4.buttonStyle,
                declineButtonStyle = _props4.declineButtonStyle,
                contentStyle = _props4.contentStyle,
                disableStyles = _props4.disableStyles,
                buttonText = _props4.buttonText,
                declineButtonText = _props4.declineButtonText,
                containerClasses = _props4.containerClasses,
                contentClasses = _props4.contentClasses,
                buttonClasses = _props4.buttonClasses,
                buttonWrapperClasses = _props4.buttonWrapperClasses,
                declineButtonClasses = _props4.declineButtonClasses,
                buttonId = _props4.buttonId,
                declineButtonId = _props4.declineButtonId,
                disableButtonStyles = _props4.disableButtonStyles,
                enableDeclineButton = _props4.enableDeclineButton,
                flipButtons = _props4.flipButtons,
                ButtonComponent = _props4.ButtonComponent,
                overlay = _props4.overlay,
                overlayClasses = _props4.overlayClasses,
                overlayStyle = _props4.overlayStyle;

              var myStyle = {};
              var myButtonStyle = {};
              var myDeclineButtonStyle = {};
              var myContentStyle = {};
              var myOverlayStyle = {};

              if (disableStyles) {
                // if styles are disabled use the provided styles (or none)
                myStyle = _extends({}, style);
                myButtonStyle = _extends({}, buttonStyle);
                myDeclineButtonStyle = _extends({}, declineButtonStyle);
                myContentStyle = _extends({}, contentStyle);
                myOverlayStyle = _extends({}, overlayStyle);
              } else {
                // if styles aren't disabled merge them with the styles that are provided (or use default styles)
                myStyle = _extends({}, _extends({}, this.state.style, style));
                myContentStyle = _extends({}, _extends({}, this.state.contentStyle, contentStyle));
                myOverlayStyle = _extends({}, _extends({}, this.state.overlayStyle, overlayStyle));

                // switch to disable JUST the button styles
                if (disableButtonStyles) {
                  myButtonStyle = _extends({}, buttonStyle);
                  myDeclineButtonStyle = _extends({}, declineButtonStyle);
                } else {
                  myButtonStyle = _extends({}, _extends({}, this.state.buttonStyle, buttonStyle));
                  myDeclineButtonStyle = _extends(
                    {},
                    _extends({}, this.state.declineButtonStyle, declineButtonStyle)
                  );
                }
              }

              // syntactic sugar to enable user to easily select top / bottom
              switch (location) {
                case OPTIONS.TOP:
                  myStyle.top = "0";
                  break;

                case OPTIONS.BOTTOM:
                  myStyle.bottom = "0";
                  break;
              }

              var buttonsToRender = [];

              // add decline button
              enableDeclineButton &&
                buttonsToRender.push(
                  _react2.default.createElement(
                    ButtonComponent,
                    {
                      key: "declineButton",
                      style: myDeclineButtonStyle,
                      className: declineButtonClasses,
                      id: declineButtonId,
                      onClick: function onClick() {
                        _this2.decline();
                      },
                    },
                    declineButtonText
                  )
                );

              // add accept button
              buttonsToRender.push(
                _react2.default.createElement(
                  ButtonComponent,
                  {
                    key: "acceptButton",
                    style: myButtonStyle,
                    className: buttonClasses,
                    id: buttonId,
                    onClick: function onClick() {
                      _this2.accept({ acceptedByScrolling: false });
                    },
                  },
                  buttonText
                )
              );

              if (flipButtons) {
                buttonsToRender.reverse();
              }

              var Wrapper = !overlay
                ? function (props) {
                    return _react2.default.createElement("div", props);
                  }
                : function (props) {
                    return _react2.default.createElement(
                      "div",
                      _extends({}, props, { style: myOverlayStyle, className: overlayClasses })
                    );
                  };

              return _react2.default.createElement(
                Wrapper,
                null,
                _react2.default.createElement(
                  "div",
                  { className: "" + containerClasses, style: myStyle },
                  _react2.default.createElement(
                    "div",
                    { style: myContentStyle, className: contentClasses },
                    this.props.children
                  ),
                  _react2.default.createElement(
                    "div",
                    { className: "" + buttonWrapperClasses },
                    buttonsToRender.map(function (button) {
                      return button;
                    })
                  )
                )
              );
            },
          },
        ]);

        return CookieConsent;
      })(_react.Component);

      CookieConsent.propTypes = {
        location: _propTypes2.default.oneOf(
          Object.keys(OPTIONS).map(function (key) {
            return OPTIONS[key];
          })
        ),
        sameSite: _propTypes2.default.oneOf(
          Object.keys(SAME_SITE_OPTIONS).map(function (key) {
            return SAME_SITE_OPTIONS[key];
          })
        ),
        style: _propTypes2.default.object,
        buttonStyle: _propTypes2.default.object,
        declineButtonStyle: _propTypes2.default.object,
        contentStyle: _propTypes2.default.object,
        children: _propTypes2.default.any, // eslint-disable-line react/forbid-prop-types
        disableStyles: _propTypes2.default.bool,
        hideOnAccept: _propTypes2.default.bool,
        hideOnDecline: _propTypes2.default.bool,
        onAccept: _propTypes2.default.func,
        onDecline: _propTypes2.default.func,
        buttonText: _propTypes2.default.oneOfType([
          _propTypes2.default.string,
          _propTypes2.default.func,
          _propTypes2.default.element,
        ]),
        declineButtonText: _propTypes2.default.oneOfType([
          _propTypes2.default.string,
          _propTypes2.default.func,
          _propTypes2.default.element,
        ]),
        cookieName: _propTypes2.default.string,
        cookieValue: _propTypes2.default.oneOfType([
          _propTypes2.default.string,
          _propTypes2.default.bool,
          _propTypes2.default.number,
        ]),
        declineCookieValue: _propTypes2.default.oneOfType([
          _propTypes2.default.string,
          _propTypes2.default.bool,
          _propTypes2.default.number,
        ]),
        setDeclineCookie: _propTypes2.default.bool,
        debug: _propTypes2.default.bool,
        expires: _propTypes2.default.number,
        containerClasses: _propTypes2.default.string,
        contentClasses: _propTypes2.default.string,
        buttonClasses: _propTypes2.default.string,
        buttonWrapperClasses: _propTypes2.default.string,
        declineButtonClasses: _propTypes2.default.string,
        buttonId: _propTypes2.default.string,
        declineButtonId: _propTypes2.default.string,
        acceptOnScroll: _propTypes2.default.bool,
        acceptOnScrollPercentage: _propTypes2.default.number,
        extraCookieOptions: _propTypes2.default.object,
        disableButtonStyles: _propTypes2.default.bool,
        enableDeclineButton: _propTypes2.default.bool,
        flipButtons: _propTypes2.default.bool,
        ButtonComponent: _propTypes2.default.elementType,
        cookieSecurity: _propTypes2.default.bool,
        overlay: _propTypes2.default.bool,
        overlayClasses: _propTypes2.default.string,
        overlayStyle: _propTypes2.default.object,
      };

      CookieConsent.defaultProps = {
        disableStyles: false,
        hideOnAccept: true,
        hideOnDecline: true,
        acceptOnScroll: false,
        acceptOnScrollPercentage: 25,
        location: OPTIONS.BOTTOM,
        onAccept: function onAccept() {},
        onDecline: function onDecline() {},
        cookieName: "CookieConsent",
        cookieValue: true,
        declineCookieValue: false,
        setDeclineCookie: true,
        buttonText: "I understand",
        declineButtonText: "I decline",
        debug: false,
        expires: 365,
        containerClasses: "CookieConsent",
        contentClasses: "",
        buttonClasses: "",
        buttonWrapperClasses: "",
        declineButtonClasses: "",
        buttonId: "rcc-confirm-button",
        declineButtonId: "rcc-decline-button",
        extraCookieOptions: {},
        disableButtonStyles: false,
        enableDeclineButton: false,
        flipButtons: false,
        sameSite: SAME_SITE_OPTIONS.NONE,
        ButtonComponent: function ButtonComponent(_ref2) {
          var children = _ref2.children,
            props = _objectWithoutProperties(_ref2, ["children"]);

          return _react2.default.createElement("button", props, children);
        },
        overlay: false,
        overlayClasses: "",
      };

      exports.default = CookieConsent;
      exports.Cookies = _jsCookie2.default;

      /***/
    },
    /* 7 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /*
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 Object(val);
      }

      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
          var test1 = new String("abc"); // eslint-disable-line no-new-wrappers
          test1[5] = "de";
          if (Object.getOwnPropertyNames(test1)[0] === "5") {
            return false;
          }

          // https://bugs.chromium.org/p/v8/issues/detail?id=3056
          var test2 = {};
          for (var i = 0; i < 10; i++) {
            test2["_" + String.fromCharCode(i)] = i;
          }
          var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
            return test2[n];
          });
          if (order2.join("") !== "0123456789") {
            return false;
          }

          // https://bugs.chromium.org/p/v8/issues/detail?id=3056
          var test3 = {};
          "abcdefghijklmnopqrst".split("").forEach(function (letter) {
            test3[letter] = letter;
          });
          if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
            return false;
          }

          return true;
        } catch (err) {
          // We don't expect any of the above to throw, but better to be safe.
          return false;
        }
      }

      module.exports = shouldUseNative()
        ? Object.assign
        : function (target, source) {
            var from;
            var to = toObject(target);
            var symbols;

            for (var s = 1; s < arguments.length; s++) {
              from = Object(arguments[s]);

              for (var key in from) {
                if (hasOwnProperty.call(from, key)) {
                  to[key] = from[key];
                }
              }

              if (getOwnPropertySymbols) {
                symbols = getOwnPropertySymbols(from);
                for (var i = 0; i < symbols.length; i++) {
                  if (propIsEnumerable.call(from, symbols[i])) {
                    to[symbols[i]] = from[symbols[i]];
                  }
                }
              }
            }

            return to;
          };

      /***/
    },
    /* 8 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /* WEBPACK VAR INJECTION */ (function (process) {
        /**
         * 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 printWarning = function () {};

        if (process.env.NODE_ENV !== "production") {
          var ReactPropTypesSecret = __webpack_require__(1);
          var loggedTypeFailures = {};
          var has = Function.call.bind(Object.prototype.hasOwnProperty);

          printWarning = function (text) {
            var message = "Warning: " + text;
            if (typeof console !== "undefined") {
              console.error(message);
            }
            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) {
          if (process.env.NODE_ENV !== "production") {
            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] +
                        "`."
                    );
                    err.name = "Invariant Violation";
                    throw 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)."
                  );
                }
                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
         */
        checkPropTypes.resetWarningCache = function () {
          if (process.env.NODE_ENV !== "production") {
            loggedTypeFailures = {};
          }
        };

        module.exports = checkPropTypes;

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(0)));

      /***/
    },
    /* 9 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /**
       * 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 = __webpack_require__(1);

      function emptyFunction() {}
      function emptyFunctionWithReset() {}
      emptyFunctionWithReset.resetWarningCache = emptyFunction;

      module.exports = function () {
        function shim(props, propName, componentName, location, propFullName, secret) {
          if (secret === ReactPropTypesSecret) {
            // It is still safe when called from React.
            return;
          }
          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;
        }
        shim.isRequired = shim;
        function getShim() {
          return shim;
        }
        // Important!
        // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
        var ReactPropTypes = {
          array: shim,
          bool: shim,
          func: shim,
          number: shim,
          object: shim,
          string: shim,
          symbol: shim,

          any: shim,
          arrayOf: getShim,
          element: shim,
          elementType: shim,
          instanceOf: getShim,
          node: shim,
          objectOf: getShim,
          oneOf: getShim,
          oneOfType: getShim,
          shape: getShim,
          exact: getShim,

          checkPropTypes: emptyFunctionWithReset,
          resetWarningCache: emptyFunction,
        };

        ReactPropTypes.PropTypes = ReactPropTypes;

        return ReactPropTypes;
      };

      /***/
    },
    /* 10 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /* WEBPACK VAR INJECTION */ (function (process) {
        /**
         * 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__(2);
        var assign = __webpack_require__(7);

        var ReactPropTypesSecret = __webpack_require__(1);
        var checkPropTypes = __webpack_require__(8);

        var has = Function.call.bind(Object.prototype.hasOwnProperty);
        var printWarning = function () {};

        if (process.env.NODE_ENV !== "production") {
          printWarning = function (text) {
            var message = "Warning: " + text;
            if (typeof console !== "undefined") {
              console.error(message);
            }
            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 emptyFunctionThatReturnsNull() {
          return null;
        }

        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"),
            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) {
            this.message = message;
            this.stack = "";
          }
          // Make `instanceof Error` still work for returned errors.
          PropTypeError.prototype = Error.prototype;

          function createChainableTypeChecker(validate) {
            if (process.env.NODE_ENV !== "production") {
              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 (
                  process.env.NODE_ENV !== "production" &&
                  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;
          }

          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 + "`.")
                );
              }
              return null;
            }
            return createChainableTypeChecker(validate);
          }

          function createAnyTypeChecker() {
            return createChainableTypeChecker(emptyFunctionThatReturnsNull);
          }

          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."
                );
              }
              var propValue = props[propName];
              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 (process.env.NODE_ENV !== "production") {
                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)) {
              process.env.NODE_ENV !== "production"
                ? printWarning(
                    "Invalid argument supplied to oneOfType, expected an instance of array."
                  )
                : void 0;
              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) {
              for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
                var checker = arrayOfTypeCheckers[i];
                if (
                  checker(
                    props,
                    propName,
                    componentName,
                    location,
                    propFullName,
                    ReactPropTypesSecret
                  ) == null
                ) {
                  return null;
                }
              }

              return new PropTypeError(
                "Invalid " +
                  location +
                  " `" +
                  propFullName +
                  "` supplied to " +
                  ("`" + componentName + "`.")
              );
            }
            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 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 (!checker) {
                  continue;
                }
                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 (!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);
            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;
        };

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(0)));

      /***/
    },
    /* 11 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /* WEBPACK VAR INJECTION */ (function (process) {
        /** @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.
         */

        if (process.env.NODE_ENV !== "production") {
          (function () {
            "use strict";

            // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
            // 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;
            }
            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;
          })();
        }

        /* WEBPACK VAR INJECTION */
      }.call(exports, __webpack_require__(0)));

      /***/
    },
    /* 12 */
    /***/ function (module, exports, __webpack_require__) {
      "use strict";
      /** @license React v16.13.1
       * react-is.production.min.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.
       */

      var b = "function" === typeof Symbol && Symbol.for,
        c = b ? Symbol.for("react.element") : 60103,
        d = b ? Symbol.for("react.portal") : 60106,
        e = b ? Symbol.for("react.fragment") : 60107,
        f = b ? Symbol.for("react.strict_mode") : 60108,
        g = b ? Symbol.for("react.profiler") : 60114,
        h = b ? Symbol.for("react.provider") : 60109,
        k = b ? Symbol.for("react.context") : 60110,
        l = b ? Symbol.for("react.async_mode") : 60111,
        m = b ? Symbol.for("react.concurrent_mode") : 60111,
        n = b ? Symbol.for("react.forward_ref") : 60112,
        p = b ? Symbol.for("react.suspense") : 60113,
        q = b ? Symbol.for("react.suspense_list") : 60120,
        r = b ? Symbol.for("react.memo") : 60115,
        t = b ? Symbol.for("react.lazy") : 60116,
        v = b ? Symbol.for("react.block") : 60121,
        w = b ? Symbol.for("react.fundamental") : 60117,
        x = b ? Symbol.for("react.responder") : 60118,
        y = b ? Symbol.for("react.scope") : 60119;
      function z(a) {
        if ("object" === typeof a && null !== a) {
          var u = a.$$typeof;
          switch (u) {
            case c:
              switch (((a = a.type), a)) {
                case l:
                case m:
                case e:
                case g:
                case f:
                case p:
                  return a;
                default:
                  switch (((a = a && a.$$typeof), a)) {
                    case k:
                    case n:
                    case t:
                    case r:
                    case h:
                      return a;
                    default:
                      return u;
                  }
              }
            case d:
              return u;
          }
        }
      }
      function A(a) {
        return z(a) === m;
      }
      exports.AsyncMode = l;
      exports.ConcurrentMode = m;
      exports.ContextConsumer = k;
      exports.ContextProvider = h;
      exports.Element = c;
      exports.ForwardRef = n;
      exports.Fragment = e;
      exports.Lazy = t;
      exports.Memo = r;
      exports.Portal = d;
      exports.Profiler = g;
      exports.StrictMode = f;
      exports.Suspense = p;
      exports.isAsyncMode = function (a) {
        return A(a) || z(a) === l;
      };
      exports.isConcurrentMode = A;
      exports.isContextConsumer = function (a) {
        return z(a) === k;
      };
      exports.isContextProvider = function (a) {
        return z(a) === h;
      };
      exports.isElement = function (a) {
        return "object" === typeof a && null !== a && a.$$typeof === c;
      };
      exports.isForwardRef = function (a) {
        return z(a) === n;
      };
      exports.isFragment = function (a) {
        return z(a) === e;
      };
      exports.isLazy = function (a) {
        return z(a) === t;
      };
      exports.isMemo = function (a) {
        return z(a) === r;
      };
      exports.isPortal = function (a) {
        return z(a) === d;
      };
      exports.isProfiler = function (a) {
        return z(a) === g;
      };
      exports.isStrictMode = function (a) {
        return z(a) === f;
      };
      exports.isSuspense = function (a) {
        return z(a) === p;
      };
      exports.isValidElementType = function (a) {
        return (
          "string" === typeof a ||
          "function" === typeof a ||
          a === e ||
          a === m ||
          a === g ||
          a === f ||
          a === p ||
          a === q ||
          ("object" === typeof a &&
            null !== a &&
            (a.$$typeof === t ||
              a.$$typeof === r ||
              a.$$typeof === h ||
              a.$$typeof === k ||
              a.$$typeof === n ||
              a.$$typeof === w ||
              a.$$typeof === x ||
              a.$$typeof === y ||
              a.$$typeof === v))
        );
      };
      exports.typeOf = z;

      /***/
    },
    /******/
  ]
);