{"version":3,"file":"static/chunks/647.7740f70b593ba500.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@u-wave/react-youtube/dist/react-youtube.es.js","webpack://_N_E/./node_modules/load-script2/index.js","webpack://_N_E/./node_modules/lodash.throttle/index.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack://_N_E/./node_modules/dom-helpers/esm/hasClass.js","webpack://_N_E/./node_modules/dom-helpers/esm/addClass.js","webpack://_N_E/./node_modules/dom-helpers/esm/removeClass.js","webpack://_N_E/./node_modules/react-transition-group/esm/config.js","webpack://_N_E/./node_modules/react-transition-group/esm/TransitionGroupContext.js","webpack://_N_E/./node_modules/react-transition-group/esm/utils/reflow.js","webpack://_N_E/./node_modules/react-transition-group/esm/Transition.js","webpack://_N_E/./node_modules/react-transition-group/esm/CSSTransition.js"],"sourcesContent":["import * as React from 'react';\nimport PropTypes from 'prop-types';\nimport loadScript from 'load-script2';\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n\n  _setPrototypeOf(subClass, superClass);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nvar eventNames = ['onReady', 'onStateChange', 'onPlaybackQualityChange', 'onPlaybackRateChange', 'onError', 'onApiChange'];\n\n/* global window */\n\nfunction loadSdk() {\n  return new Promise(function (resolve, reject) {\n    if (typeof window.YT === 'object' && typeof window.YT.ready === 'function') {\n      // A YouTube SDK is already loaded, so reuse that\n      window.YT.ready(function () {\n        resolve(window.YT);\n      });\n      return;\n    }\n\n    loadScript('https://www.youtube.com/iframe_api', function (err) {\n      if (err) {\n        reject(err);\n      } else {\n        window.YT.ready(function () {\n          resolve(window.YT);\n        });\n      }\n    });\n  });\n}\n\nvar sdk = null;\nfunction getSdk() {\n  if (!sdk) {\n    sdk = loadSdk();\n  }\n\n  return sdk;\n}\n\nvar YouTube = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(YouTube, _React$Component);\n\n  function YouTube(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n    _this.onPlayerReady = _this.onPlayerReady.bind(_assertThisInitialized(_this));\n    _this.onPlayerStateChange = _this.onPlayerStateChange.bind(_assertThisInitialized(_this));\n    _this.refContainer = _this.refContainer.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  var _proto = YouTube.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.createPlayer();\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var _this2 = this;\n\n    // eslint-disable-next-line react/destructuring-assignment\n    var changes = Object.keys(this.props).filter(function (name) {\n      return _this2.props[name] !== prevProps[name];\n    });\n    this.updateProps(changes);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    if (this.playerInstance) {\n      this.playerInstance.destroy();\n    }\n  };\n\n  _proto.onPlayerReady = function onPlayerReady(event) {\n    var _this$props = this.props,\n        volume = _this$props.volume,\n        muted = _this$props.muted,\n        suggestedQuality = _this$props.suggestedQuality,\n        playbackRate = _this$props.playbackRate;\n\n    if (typeof volume !== 'undefined') {\n      event.target.setVolume(volume * 100);\n    }\n\n    if (typeof muted !== 'undefined') {\n      if (muted) {\n        event.target.mute();\n      } else {\n        event.target.unMute();\n      }\n    }\n\n    if (typeof suggestedQuality !== 'undefined') {\n      event.target.setPlaybackQuality(suggestedQuality);\n    }\n\n    if (typeof playbackRate !== 'undefined') {\n      event.target.setPlaybackRate(playbackRate);\n    }\n\n    this.resolvePlayer(event.target);\n  };\n\n  _proto.onPlayerStateChange = function onPlayerStateChange(event) {\n    var _this$props2 = this.props,\n        onCued = _this$props2.onCued,\n        onBuffering = _this$props2.onBuffering,\n        onPause = _this$props2.onPause,\n        onPlaying = _this$props2.onPlaying,\n        onEnd = _this$props2.onEnd;\n    var State = YT.PlayerState; // eslint-disable-line no-undef\n\n    switch (event.data) {\n      case State.CUED:\n        onCued(event);\n        break;\n\n      case State.BUFFERING:\n        onBuffering(event);\n        break;\n\n      case State.PAUSED:\n        onPause(event);\n        break;\n\n      case State.PLAYING:\n        onPlaying(event);\n        break;\n\n      case State.ENDED:\n        onEnd(event);\n        break;\n\n    }\n  }\n  /**\n   * @private\n   */\n  ;\n\n  _proto.getPlayerParameters = function getPlayerParameters() {\n    /* eslint-disable react/destructuring-assignment */\n    return {\n      autoplay: this.props.autoplay,\n      cc_load_policy: this.props.showCaptions ? 1 : 0,\n      controls: this.props.controls ? 1 : 0,\n      disablekb: this.props.disableKeyboard ? 1 : 0,\n      fs: this.props.allowFullscreen ? 1 : 0,\n      hl: this.props.lang,\n      iv_load_policy: this.props.annotations ? 1 : 3,\n      start: this.props.startSeconds,\n      end: this.props.endSeconds,\n      modestbranding: this.props.modestBranding ? 1 : 0,\n      playsinline: this.props.playsInline ? 1 : 0,\n      rel: this.props.showRelatedVideos ? 1 : 0\n    };\n    /* eslint-enable react/destructuring-assignment */\n  }\n  /**\n   * @private\n   */\n  ;\n\n  _proto.getInitialOptions = function getInitialOptions() {\n    /* eslint-disable react/destructuring-assignment */\n    return {\n      videoId: this.props.video,\n      width: this.props.width,\n      height: this.props.height,\n      playerVars: this.getPlayerParameters(),\n      events: {\n        onReady: this.onPlayerReady,\n        onStateChange: this.onPlayerStateChange\n      }\n    };\n    /* eslint-enable react/destructuring-assignment */\n  }\n  /**\n   * @private\n   */\n  ;\n\n  _proto.updateProps = function updateProps(propNames) {\n    var _this3 = this;\n\n    this.player.then(function (player) {\n      propNames.forEach(function (name) {\n        // eslint-disable-next-line react/destructuring-assignment\n        var value = _this3.props[name];\n\n        switch (name) {\n          case 'muted':\n            if (value) {\n              player.mute();\n            } else {\n              player.unMute();\n            }\n\n            break;\n\n          case 'suggestedQuality':\n            player.setPlaybackQuality(value);\n            break;\n\n          case 'volume':\n            player.setVolume(value * 100);\n            break;\n\n          case 'paused':\n            if (value && player.getPlayerState() !== 2) {\n              player.pauseVideo();\n            } else if (!value && player.getPlayerState() === 2) {\n              player.playVideo();\n            }\n\n            break;\n\n          case 'id':\n          case 'className':\n          case 'width':\n          case 'height':\n            player.getIframe()[name] = value; // eslint-disable-line no-param-reassign\n\n            break;\n\n          case 'video':\n            if (!value) {\n              player.stopVideo();\n            } else {\n              var _this3$props = _this3.props,\n                  startSeconds = _this3$props.startSeconds,\n                  endSeconds = _this3$props.endSeconds,\n                  autoplay = _this3$props.autoplay;\n              var opts = {\n                videoId: value,\n                startSeconds: startSeconds || 0,\n                endSeconds: endSeconds\n              };\n\n              if (autoplay) {\n                player.loadVideoById(opts);\n              } else {\n                player.cueVideoById(opts);\n              }\n            }\n\n            break;\n\n        }\n      });\n    });\n  }\n  /**\n   * @private\n   */\n  ;\n\n  _proto.createPlayer = function createPlayer() {\n    var _this4 = this;\n\n    var volume = this.props.volume;\n    this.player = getSdk().then(function (YT) {\n      return new Promise(function (resolve) {\n        _this4.resolvePlayer = resolve;\n        var player = new YT.Player(_this4.container, _this4.getInitialOptions()); // Store the instance directly so we can destroy it sync in\n        // `componentWillUnmount`.\n\n        _this4.playerInstance = player;\n        eventNames.forEach(function (name) {\n          player.addEventListener(name, function (event) {\n            // eslint-disable-next-line react/destructuring-assignment\n            var handler = _this4.props[name];\n\n            if (handler) {\n              handler(event);\n            }\n          });\n        });\n      });\n    });\n\n    if (typeof volume === 'number') {\n      this.updateProps(['volume']);\n    }\n  }\n  /**\n   * @private\n   */\n  ;\n\n  _proto.refContainer = function refContainer(container) {\n    this.container = container;\n  };\n\n  _proto.render = function render() {\n    var _this$props3 = this.props,\n        id = _this$props3.id,\n        className = _this$props3.className,\n        style = _this$props3.style;\n    return /*#__PURE__*/React.createElement(\"div\", {\n      id: id,\n      className: className,\n      style: style,\n      ref: this.refContainer\n    });\n  };\n\n  return YouTube;\n}(React.Component);\n\nif (process.env.NODE_ENV !== 'production') {\n  YouTube.propTypes = {\n    /**\n     * An 11-character string representing a YouTube video ID..\n     */\n    video: PropTypes.string,\n\n    /**\n     * DOM ID for the player element.\n     */\n    id: PropTypes.string,\n\n    /**\n     * CSS className for the player element.\n     */\n    className: PropTypes.string,\n\n    /**\n     * Inline style for container element.\n     */\n    style: PropTypes.object,\n    // eslint-disable-line react/forbid-prop-types\n\n    /**\n     * Width of the player element.\n     */\n    width: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n\n    /**\n     * Height of the player element.\n     */\n    height: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n\n    /**\n     * Pause the video.\n     */\n    paused: PropTypes.bool,\n    // eslint-disable-line react/no-unused-prop-types\n    // Player parameters\n\n    /**\n     * Whether the video should start playing automatically.\n     *\n     * https://developers.google.com/youtube/player_parameters#autoplay\n     */\n    autoplay: PropTypes.bool,\n\n    /**\n     * Whether to show captions below the video.\n     *\n     * https://developers.google.com/youtube/player_parameters#cc_load_policy\n     */\n    showCaptions: PropTypes.bool,\n\n    /**\n     * Whether to show video controls.\n     *\n     * https://developers.google.com/youtube/player_parameters#controls\n     */\n    controls: PropTypes.bool,\n\n    /**\n     * Ignore keyboard controls.\n     *\n     * https://developers.google.com/youtube/player_parameters#disablekb\n     */\n    disableKeyboard: PropTypes.bool,\n\n    /**\n     * Whether to display the fullscreen button.\n     *\n     * https://developers.google.com/youtube/player_parameters#fs\n     */\n    allowFullscreen: PropTypes.bool,\n\n    /**\n     * The player's interface language. The parameter value is an ISO 639-1\n     * two-letter language code or a fully specified locale.\n     *\n     * https://developers.google.com/youtube/player_parameters#hl\n     */\n    lang: PropTypes.string,\n\n    /**\n     * Whether to show annotations on top of the video.\n     *\n     * https://developers.google.com/youtube/player_parameters#iv_load_policy\n     */\n    annotations: PropTypes.bool,\n\n    /**\n     * Time in seconds at which to start playing the video.\n     *\n     * https://developers.google.com/youtube/player_parameters#start\n     */\n    startSeconds: PropTypes.number,\n\n    /**\n     * Time in seconds at which to stop playing the video.\n     *\n     * https://developers.google.com/youtube/player_parameters#end\n     */\n    endSeconds: PropTypes.number,\n\n    /**\n     * Remove most YouTube logos from the player.\n     *\n     * https://developers.google.com/youtube/player_parameters#modestbranding\n     */\n    modestBranding: PropTypes.bool,\n\n    /**\n     * Whether to play the video inline on iOS, instead of fullscreen.\n     *\n     * https://developers.google.com/youtube/player_parameters#playsinline\n     */\n    playsInline: PropTypes.bool,\n\n    /**\n     * Whether to show related videos after the video is over.\n     *\n     * https://developers.google.com/youtube/player_parameters#rel\n     */\n    showRelatedVideos: PropTypes.bool,\n\n    /**\n     * The playback volume, **as a number between 0 and 1**.\n     */\n    volume: PropTypes.number,\n\n    /**\n     * Whether the video's sound should be muted.\n     */\n    muted: PropTypes.bool,\n\n    /**\n     * The suggested playback quality.\n     *\n     * https://developers.google.com/youtube/iframe_api_reference#Playback_quality\n     */\n    suggestedQuality: PropTypes.string,\n\n    /**\n     * Playback speed.\n     *\n     * https://developers.google.com/youtube/iframe_api_reference#setPlaybackRate\n     */\n    playbackRate: PropTypes.number,\n    // Events\n\n    /* eslint-disable react/no-unused-prop-types */\n\n    /**\n     * Sent when the YouTube player API has loaded.\n     */\n    onReady: PropTypes.func,\n\n    /**\n     * Sent when the player triggers an error.\n     */\n    onError: PropTypes.func,\n\n    /**\n     * Sent when the video is cued and ready to play.\n     */\n    onCued: PropTypes.func,\n\n    /**\n     * Sent when the video is buffering.\n     */\n    onBuffering: PropTypes.func,\n\n    /**\n     * Sent when playback has been started or resumed.\n     */\n    onPlaying: PropTypes.func,\n\n    /**\n     * Sent when playback has been paused.\n     */\n    onPause: PropTypes.func,\n\n    /**\n     * Sent when playback has stopped.\n     */\n    onEnd: PropTypes.func,\n    onStateChange: PropTypes.func,\n    onPlaybackRateChange: PropTypes.func,\n    onPlaybackQualityChange: PropTypes.func\n    /* eslint-enable react/no-unused-prop-types */\n\n  };\n}\n\nYouTube.defaultProps = {\n  autoplay: false,\n  showCaptions: false,\n  controls: true,\n  disableKeyboard: false,\n  allowFullscreen: true,\n  annotations: true,\n  modestBranding: false,\n  playsInline: false,\n  showRelatedVideos: true,\n  onCued: function onCued() {},\n  onBuffering: function onBuffering() {},\n  onPlaying: function onPlaying() {},\n  onPause: function onPause() {},\n  onEnd: function onEnd() {}\n};\n\nexport { YouTube as default };\n","module.exports = load\n\nfunction load (src, cb) {\n  var head = document.head || document.getElementsByTagName('head')[0]\n  var script = document.createElement('script')\n\n  script.type = 'text/javascript'\n  script.async = true\n  script.src = src\n\n  if (cb) {\n    script.onload = function () {\n      script.onerror = script.onload = null\n      cb(null, script)\n    }\n    script.onerror = function () {\n      script.onerror = script.onload = null\n      cb(new Error('Failed to load ' + src), script)\n    }\n  }\n\n  head.appendChild(script)\n}\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = throttle;\n","function _setPrototypeOf(t, e) {\n  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n    return t.__proto__ = e, t;\n  }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inheritsLoose(t, o) {\n  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o);\n}\nexport { _inheritsLoose as default };","/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","export default {\n  disabled: false\n};","import React from 'react';\nexport default React.createContext(null);","export var forceReflow = function forceReflow(node) {\n  return node.scrollTop;\n};","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { forceReflow } from './utils/reflow';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        if (this.props.unmountOnExit || this.props.mountOnEnter) {\n          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749\n          // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.\n          // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.\n\n          if (node) forceReflow(node);\n        }\n\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : function (propValue, key, componentName, location, propFullName, secret) {\n      var value = propValue[key];\n      return PropTypes.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);\n    }\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport addOneClass from 'dom-helpers/addClass';\nimport removeOneClass from 'dom-helpers/removeClass';\nimport React from 'react';\nimport Transition from './Transition';\nimport { classNamesShape } from './utils/PropTypes';\nimport { forceReflow } from './utils/reflow';\n\nvar _addClass = function addClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return addOneClass(node, c);\n  });\n};\n\nvar removeClass = function removeClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return removeOneClass(node, c);\n  });\n};\n/**\n * A transition component inspired by the excellent\n * [ng-animate](https://docs.angularjs.org/api/ngAnimate) library, you should\n * use it if you're using CSS transitions or animations. It's built upon the\n * [`Transition`](https://reactcommunity.org/react-transition-group/transition)\n * component, so it inherits all of its props.\n *\n * `CSSTransition` applies a pair of class names during the `appear`, `enter`,\n * and `exit` states of the transition. The first class is applied and then a\n * second `*-active` class in order to activate the CSS transition. After the\n * transition, matching `*-done` class names are applied to persist the\n * transition state.\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <CSSTransition in={inProp} timeout={200} classNames=\"my-node\">\n *         <div>\n *           {\"I'll receive my-node-* classes\"}\n *         </div>\n *       </CSSTransition>\n *       <button type=\"button\" onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the `in` prop is set to `true`, the child component will first receive\n * the class `example-enter`, then the `example-enter-active` will be added in\n * the next tick. `CSSTransition` [forces a\n * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)\n * between before adding the `example-enter-active`. This is an important trick\n * because it allows us to transition between `example-enter` and\n * `example-enter-active` even though they were added immediately one after\n * another. Most notably, this is what makes it possible for us to animate\n * _appearance_.\n *\n * ```css\n * .my-node-enter {\n *   opacity: 0;\n * }\n * .my-node-enter-active {\n *   opacity: 1;\n *   transition: opacity 200ms;\n * }\n * .my-node-exit {\n *   opacity: 1;\n * }\n * .my-node-exit-active {\n *   opacity: 0;\n *   transition: opacity 200ms;\n * }\n * ```\n *\n * `*-active` classes represent which styles you want to animate **to**, so it's\n * important to add `transition` declaration only to them, otherwise transitions\n * might not behave as intended! This might not be obvious when the transitions\n * are symmetrical, i.e. when `*-enter-active` is the same as `*-exit`, like in\n * the example above (minus `transition`), but it becomes apparent in more\n * complex transitions.\n *\n * **Note**: If you're using the\n * [`appear`](http://reactcommunity.org/react-transition-group/transition#Transition-prop-appear)\n * prop, make sure to define styles for `.appear-*` classes as well.\n */\n\n\nvar CSSTransition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(CSSTransition, _React$Component);\n\n  function CSSTransition() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.appliedClasses = {\n      appear: {},\n      enter: {},\n      exit: {}\n    };\n\n    _this.onEnter = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument[0],\n          appearing = _this$resolveArgument[1];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, appearing ? 'appear' : 'enter', 'base');\n\n      if (_this.props.onEnter) {\n        _this.props.onEnter(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntering = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument2 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument2[0],\n          appearing = _this$resolveArgument2[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.addClass(node, type, 'active');\n\n      if (_this.props.onEntering) {\n        _this.props.onEntering(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntered = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument3 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument3[0],\n          appearing = _this$resolveArgument3[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.removeClasses(node, type);\n\n      _this.addClass(node, type, 'done');\n\n      if (_this.props.onEntered) {\n        _this.props.onEntered(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onExit = function (maybeNode) {\n      var _this$resolveArgument4 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument4[0];\n\n      _this.removeClasses(node, 'appear');\n\n      _this.removeClasses(node, 'enter');\n\n      _this.addClass(node, 'exit', 'base');\n\n      if (_this.props.onExit) {\n        _this.props.onExit(maybeNode);\n      }\n    };\n\n    _this.onExiting = function (maybeNode) {\n      var _this$resolveArgument5 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument5[0];\n\n      _this.addClass(node, 'exit', 'active');\n\n      if (_this.props.onExiting) {\n        _this.props.onExiting(maybeNode);\n      }\n    };\n\n    _this.onExited = function (maybeNode) {\n      var _this$resolveArgument6 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument6[0];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, 'exit', 'done');\n\n      if (_this.props.onExited) {\n        _this.props.onExited(maybeNode);\n      }\n    };\n\n    _this.resolveArguments = function (maybeNode, maybeAppearing) {\n      return _this.props.nodeRef ? [_this.props.nodeRef.current, maybeNode] // here `maybeNode` is actually `appearing`\n      : [maybeNode, maybeAppearing];\n    };\n\n    _this.getClassNames = function (type) {\n      var classNames = _this.props.classNames;\n      var isStringClassNames = typeof classNames === 'string';\n      var prefix = isStringClassNames && classNames ? classNames + \"-\" : '';\n      var baseClassName = isStringClassNames ? \"\" + prefix + type : classNames[type];\n      var activeClassName = isStringClassNames ? baseClassName + \"-active\" : classNames[type + \"Active\"];\n      var doneClassName = isStringClassNames ? baseClassName + \"-done\" : classNames[type + \"Done\"];\n      return {\n        baseClassName: baseClassName,\n        activeClassName: activeClassName,\n        doneClassName: doneClassName\n      };\n    };\n\n    return _this;\n  }\n\n  var _proto = CSSTransition.prototype;\n\n  _proto.addClass = function addClass(node, type, phase) {\n    var className = this.getClassNames(type)[phase + \"ClassName\"];\n\n    var _this$getClassNames = this.getClassNames('enter'),\n        doneClassName = _this$getClassNames.doneClassName;\n\n    if (type === 'appear' && phase === 'done' && doneClassName) {\n      className += \" \" + doneClassName;\n    } // This is to force a repaint,\n    // which is necessary in order to transition styles when adding a class name.\n\n\n    if (phase === 'active') {\n      if (node) forceReflow(node);\n    }\n\n    if (className) {\n      this.appliedClasses[type][phase] = className;\n\n      _addClass(node, className);\n    }\n  };\n\n  _proto.removeClasses = function removeClasses(node, type) {\n    var _this$appliedClasses$ = this.appliedClasses[type],\n        baseClassName = _this$appliedClasses$.base,\n        activeClassName = _this$appliedClasses$.active,\n        doneClassName = _this$appliedClasses$.done;\n    this.appliedClasses[type] = {};\n\n    if (baseClassName) {\n      removeClass(node, baseClassName);\n    }\n\n    if (activeClassName) {\n      removeClass(node, activeClassName);\n    }\n\n    if (doneClassName) {\n      removeClass(node, doneClassName);\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        _ = _this$props.classNames,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"classNames\"]);\n\n    return /*#__PURE__*/React.createElement(Transition, _extends({}, props, {\n      onEnter: this.onEnter,\n      onEntered: this.onEntered,\n      onEntering: this.onEntering,\n      onExit: this.onExit,\n      onExiting: this.onExiting,\n      onExited: this.onExited\n    }));\n  };\n\n  return CSSTransition;\n}(React.Component);\n\nCSSTransition.defaultProps = {\n  classNames: ''\n};\nCSSTransition.propTypes = process.env.NODE_ENV !== \"production\" ? _extends({}, Transition.propTypes, {\n  /**\n   * The animation classNames applied to the component as it appears, enters,\n   * exits or has finished the transition. A single name can be provided, which\n   * will be suffixed for each stage, e.g. `classNames=\"fade\"` applies:\n   *\n   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`\n   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`\n   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`\n   *\n   * A few details to note about how these classes are applied:\n   *\n   * 1. They are _joined_ with the ones that are already defined on the child\n   *    component, so if you want to add some base styles, you can use\n   *    `className` without worrying that it will be overridden.\n   *\n   * 2. If the transition component mounts with `in={false}`, no classes are\n   *    applied yet. You might be expecting `*-exit-done`, but if you think\n   *    about it, a component cannot finish exiting if it hasn't entered yet.\n   *\n   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This\n   *    allows you to define different behavior for when appearing is done and\n   *    when regular entering is done, using selectors like\n   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply\n   *    an epic entrance animation when element first appears in the DOM using\n   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can\n   *    simply use `fade-enter-done` for defining both cases.\n   *\n   * Each individual classNames can also be specified independently like:\n   *\n   * ```js\n   * classNames={{\n   *  appear: 'my-appear',\n   *  appearActive: 'my-active-appear',\n   *  appearDone: 'my-done-appear',\n   *  enter: 'my-enter',\n   *  enterActive: 'my-active-enter',\n   *  enterDone: 'my-done-enter',\n   *  exit: 'my-exit',\n   *  exitActive: 'my-active-exit',\n   *  exitDone: 'my-done-exit',\n   * }}\n   * ```\n   *\n   * If you want to set these classes using CSS Modules:\n   *\n   * ```js\n   * import styles from './styles.css';\n   * ```\n   *\n   * you might want to use camelCase in your CSS file, that way could simply\n   * spread them instead of listing them one by one:\n   *\n   * ```js\n   * classNames={{ ...styles }}\n   * ```\n   *\n   * @type {string | {\n   *  appear?: string,\n   *  appearActive?: string,\n   *  appearDone?: string,\n   *  enter?: string,\n   *  enterActive?: string,\n   *  enterDone?: string,\n   *  exit?: string,\n   *  exitActive?: string,\n   *  exitDone?: string,\n   * }}\n   */\n  classNames: classNamesShape,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter-active' or\n   * 'appear-active' class is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or\n   * 'appear' classes are **removed** and the `done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' classes\n   * are **removed** and the `exit-done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExited: PropTypes.func\n}) : {};\nexport default CSSTransition;"],"names":["_setPrototypeOf","o","p","Object","setPrototypeOf","__proto__","_assertThisInitialized","self","eventNames","sdk","YouTube","_React$Component","props","_this","call","onPlayerReady","bind","onPlayerStateChange","refContainer","subClass","prototype","create","superClass","constructor","_proto","componentDidMount","createPlayer","componentDidUpdate","prevProps","_this2","changes","keys","filter","name","updateProps","componentWillUnmount","playerInstance","destroy","event","_this$props","volume","muted","suggestedQuality","playbackRate","target","setVolume","mute","unMute","setPlaybackQuality","setPlaybackRate","resolvePlayer","_this$props2","onCued","onBuffering","onPause","onPlaying","onEnd","State","YT","PlayerState","data","CUED","BUFFERING","PAUSED","PLAYING","ENDED","getPlayerParameters","autoplay","cc_load_policy","showCaptions","controls","disablekb","disableKeyboard","fs","allowFullscreen","hl","lang","iv_load_policy","annotations","start","startSeconds","end","endSeconds","modestbranding","modestBranding","playsinline","playsInline","rel","showRelatedVideos","getInitialOptions","videoId","video","width","height","playerVars","events","onReady","onStateChange","propNames","_this3","player","then","forEach","value","getPlayerState","pauseVideo","playVideo","getIframe","_this3$props","opts","loadVideoById","cueVideoById","stopVideo","_this4","getSdk","Promise","resolve","reject","window","ready","load_script2__WEBPACK_IMPORTED_MODULE_1___default","err","Player","container","addEventListener","handler","render","_this$props3","id","className","style","react__WEBPACK_IMPORTED_MODULE_0__","createElement","ref","Component","defaultProps","module","exports","src","cb","head","document","getElementsByTagName","script","type","async","onload","onerror","appendChild","FUNC_ERROR_TEXT","NAN","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","__webpack_require__","g","freeSelf","root","Function","objectToString","objectProto","toString","nativeMax","Math","max","nativeMin","min","now","Date","isObject","toNumber","isObjectLike","other","valueOf","replace","isBinary","test","slice","func","wait","options","leading","trailing","debounce","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","maxing","invokeFunc","time","args","thisArg","undefined","apply","shouldInvoke","timeSinceLastCall","timeSinceLastInvoke","timerExpired","trailingEdge","setTimeout","debounced","isInvoking","arguments","cancel","clearTimeout","flush","t","e","_inheritsLoose","replaceClassName","origClass","classToRemove","config","disabled","TransitionGroupContext","react","createContext","forceReflow","node","scrollTop","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","Transition","context","initialStatus","appear","parentGroup","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","getDerivedStateFromProps","_ref","prevState","updateStatus","nextStatus","cancelNextCallback","getTimeouts","exit","timeout","mounting","nodeRef","current","react_dom","findDOMNode","performEnter","performExit","setState","appearing","_ref2","maybeNode","maybeAppearing","timeouts","enterTimeout","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","onExited","onExit","onExiting","nextState","callback","setNextCallback","active","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","children","childProps","objectWithoutPropertiesLoose","Z","Provider","cloneElement","Children","only","noop","contextType","propTypes","removeClass","classes","split","c","element","classList","remove","setAttribute","baseVal","CSSTransition","_len","length","_key","concat","appliedClasses","_this$resolveArgument","resolveArguments","removeClasses","addClass","_this$resolveArgument2","_this$resolveArgument3","_this$resolveArgument4","_this$resolveArgument5","_this$resolveArgument6","getClassNames","classNames","isStringClassNames","baseClassName","activeClassName","doneClassName","phase","_this$getClassNames","add","contains","indexOf","_this$appliedClasses$","base","done","esm_extends","esm_CSSTransition"],"sourceRoot":""}