{"version":3,"file":"main/static/js/947.15222aed.js","mappings":"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","sources":["../../../node_modules/ahooks/es/utils/index.js","../../../node_modules/ahooks/es/utils/isBrowser.js","../../../node_modules/ahooks/es/utils/domTarget.js","../../../node_modules/ahooks/es/useLatest/index.js","../../../node_modules/ahooks/es/useUnmount/index.js","../../../node_modules/ahooks/es/utils/depsAreSame.js","../../../node_modules/ahooks/es/utils/createEffectWithTarget.js","../../../node_modules/ahooks/es/utils/useEffectWithTarget.js","../../../node_modules/ahooks/es/useInViewport/index.js","../../../node_modules/ahooks/node_modules/intersection-observer/intersection-observer.js","../../../node_modules/querystring/decode.js","../../../node_modules/querystring/encode.js","../../../node_modules/querystring/index.js","../../../node_modules/scroll-into-view-if-needed/es/index.js"],"sourcesContent":["export var isObject = function (value) {\n  return value !== null && typeof value === 'object';\n};\nexport var isFunction = function (value) {\n  return typeof value === 'function';\n};\nexport var isString = function (value) {\n  return typeof value === 'string';\n};\nexport var isBoolean = function (value) {\n  return typeof value === 'boolean';\n};\nexport var isNumber = function (value) {\n  return typeof value === 'number';\n};\nexport var isUndef = function (value) {\n  return typeof value === 'undefined';\n};","var isBrowser = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nexport default isBrowser;","import { isFunction } from './index';\nimport isBrowser from './isBrowser';\nexport function getTargetElement(target, defaultElement) {\n  if (!isBrowser) {\n    return undefined;\n  }\n  if (!target) {\n    return defaultElement;\n  }\n  var targetElement;\n  if (isFunction(target)) {\n    targetElement = target();\n  } else if ('current' in target) {\n    targetElement = target.current;\n  } else {\n    targetElement = target;\n  }\n  return targetElement;\n}","import { useRef } from 'react';\nfunction useLatest(value) {\n  var ref = useRef(value);\n  ref.current = value;\n  return ref;\n}\nexport default useLatest;","import { useEffect } from 'react';\nimport useLatest from '../useLatest';\nimport { isFunction } from '../utils';\nimport isDev from '../utils/isDev';\nvar useUnmount = function (fn) {\n  if (isDev) {\n    if (!isFunction(fn)) {\n      console.error(\"useUnmount expected parameter is a function, got \".concat(typeof fn));\n    }\n  }\n  var fnRef = useLatest(fn);\n  useEffect(function () {\n    return function () {\n      fnRef.current();\n    };\n  }, []);\n};\nexport default useUnmount;","export default function depsAreSame(oldDeps, deps) {\n  if (oldDeps === deps) return true;\n  for (var i = 0; i < oldDeps.length; i++) {\n    if (!Object.is(oldDeps[i], deps[i])) return false;\n  }\n  return true;\n}","import { useRef } from 'react';\nimport useUnmount from '../useUnmount';\nimport depsAreSame from './depsAreSame';\nimport { getTargetElement } from './domTarget';\nvar createEffectWithTarget = function (useEffectType) {\n  /**\n   *\n   * @param effect\n   * @param deps\n   * @param target target should compare ref.current vs ref.current, dom vs dom, ()=>dom vs ()=>dom\n   */\n  var useEffectWithTarget = function (effect, deps, target) {\n    var hasInitRef = useRef(false);\n    var lastElementRef = useRef([]);\n    var lastDepsRef = useRef([]);\n    var unLoadRef = useRef();\n    useEffectType(function () {\n      var _a;\n      var targets = Array.isArray(target) ? target : [target];\n      var els = targets.map(function (item) {\n        return getTargetElement(item);\n      });\n      // init run\n      if (!hasInitRef.current) {\n        hasInitRef.current = true;\n        lastElementRef.current = els;\n        lastDepsRef.current = deps;\n        unLoadRef.current = effect();\n        return;\n      }\n      if (els.length !== lastElementRef.current.length || !depsAreSame(els, lastElementRef.current) || !depsAreSame(deps, lastDepsRef.current)) {\n        (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);\n        lastElementRef.current = els;\n        lastDepsRef.current = deps;\n        unLoadRef.current = effect();\n      }\n    });\n    useUnmount(function () {\n      var _a;\n      (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);\n      // for react-refresh\n      hasInitRef.current = false;\n    });\n  };\n  return useEffectWithTarget;\n};\nexport default createEffectWithTarget;","import { useEffect } from 'react';\nimport createEffectWithTarget from './createEffectWithTarget';\nvar useEffectWithTarget = createEffectWithTarget(useEffect);\nexport default useEffectWithTarget;","import { __assign, __read, __rest, __values } from \"tslib\";\nimport 'intersection-observer';\nimport { useState } from 'react';\nimport { getTargetElement } from '../utils/domTarget';\nimport useEffectWithTarget from '../utils/useEffectWithTarget';\nfunction useInViewport(target, options) {\n  var _a = options || {},\n    callback = _a.callback,\n    option = __rest(_a, [\"callback\"]);\n  var _b = __read(useState(), 2),\n    state = _b[0],\n    setState = _b[1];\n  var _c = __read(useState(), 2),\n    ratio = _c[0],\n    setRatio = _c[1];\n  useEffectWithTarget(function () {\n    var targets = Array.isArray(target) ? target : [target];\n    var els = targets.map(function (element) {\n      return getTargetElement(element);\n    }).filter(Boolean);\n    if (!els.length) {\n      return;\n    }\n    var observer = new IntersectionObserver(function (entries) {\n      var e_1, _a;\n      try {\n        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {\n          var entry = entries_1_1.value;\n          setRatio(entry.intersectionRatio);\n          setState(entry.isIntersecting);\n          callback === null || callback === void 0 ? void 0 : callback(entry);\n        }\n      } catch (e_1_1) {\n        e_1 = {\n          error: e_1_1\n        };\n      } finally {\n        try {\n          if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);\n        } finally {\n          if (e_1) throw e_1.error;\n        }\n      }\n    }, __assign(__assign({}, option), {\n      root: getTargetElement(options === null || options === void 0 ? void 0 : options.root)\n    }));\n    els.forEach(function (el) {\n      if (el) {\n        observer.observe(el);\n      }\n    });\n    return function () {\n      observer.disconnect();\n    };\n  }, [options === null || options === void 0 ? void 0 : options.rootMargin, options === null || options === void 0 ? void 0 : options.threshold, callback], target);\n  return [state, ratio];\n}\nexport default useInViewport;","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function() {\n'use strict';\n\n// Exit early if we're not running in a browser.\nif (typeof window !== 'object') {\n  return;\n}\n\n// Exit early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n/**\n * Returns the embedding frame element, if any.\n * @param {!Document} doc\n * @return {!Element}\n */\nfunction getFrameElement(doc) {\n  try {\n    return doc.defaultView && doc.defaultView.frameElement || null;\n  } catch (e) {\n    // Ignore the error.\n    return null;\n  }\n}\n\n/**\n * A local reference to the root document.\n */\nvar document = (function(startDoc) {\n  var doc = startDoc;\n  var frame = getFrameElement(doc);\n  while (frame) {\n    doc = frame.ownerDocument;\n    frame = getFrameElement(doc);\n  }\n  return doc;\n})(window.document);\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n/**\n * The signal updater for cross-origin intersection. When not null, it means\n * that the polyfill is configured to work in a cross-origin mode.\n * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nvar crossOriginUpdater = null;\n\n/**\n * The current cross-origin intersection. Only used in the cross-origin mode.\n * @type {DOMRect|ClientRect}\n */\nvar crossOriginRect = null;\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = ensureDOMRect(entry.rootBounds);\n  this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);\n  this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (\n    options.root &&\n    options.root.nodeType != 1 &&\n    options.root.nodeType != 9\n  ) {\n    throw new Error('root must be a Document or Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n\n  /** @private @const {!Array<!Document>} */\n  this._monitoringDocuments = [];\n  /** @private @const {!Array<function()>} */\n  this._monitoringUnsubscribes = [];\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Sets up the polyfill in the cross-origin mode. The result is the\n * updater function that accepts two arguments: `boundingClientRect` and\n * `intersectionRect` - just as these fields would be available to the\n * parent via `IntersectionObserverEntry`. This function should be called\n * each time the iframe receives intersection information from the parent\n * window, e.g. via messaging.\n * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nIntersectionObserver._setupCrossOriginUpdater = function() {\n  if (!crossOriginUpdater) {\n    /**\n     * @param {DOMRect|ClientRect} boundingClientRect\n     * @param {DOMRect|ClientRect} intersectionRect\n     */\n    crossOriginUpdater = function(boundingClientRect, intersectionRect) {\n      if (!boundingClientRect || !intersectionRect) {\n        crossOriginRect = getEmptyRect();\n      } else {\n        crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);\n      }\n      registry.forEach(function(observer) {\n        observer._checkForIntersections();\n      });\n    };\n  }\n  return crossOriginUpdater;\n};\n\n\n/**\n * Resets the cross-origin mode.\n */\nIntersectionObserver._resetCrossOriginUpdater = function() {\n  crossOriginUpdater = null;\n  crossOriginRect = null;\n};\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections(target.ownerDocument);\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n        return item.element != target;\n      });\n  this._unmonitorIntersections(target.ownerDocument);\n  if (this._observationTargets.length == 0) {\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorAllIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function(doc) {\n  var win = doc.defaultView;\n  if (!win) {\n    // Already destroyed.\n    return;\n  }\n  if (this._monitoringDocuments.indexOf(doc) != -1) {\n    // Already monitoring.\n    return;\n  }\n\n  // Private state for monitoring.\n  var callback = this._checkForIntersections;\n  var monitoringInterval = null;\n  var domObserver = null;\n\n  // If a poll interval is set, use polling instead of listening to\n  // resize and scroll events or DOM mutations.\n  if (this.POLL_INTERVAL) {\n    monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);\n  } else {\n    addEvent(win, 'resize', callback, true);\n    addEvent(doc, 'scroll', callback, true);\n    if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {\n      domObserver = new win.MutationObserver(callback);\n      domObserver.observe(doc, {\n        attributes: true,\n        childList: true,\n        characterData: true,\n        subtree: true\n      });\n    }\n  }\n\n  this._monitoringDocuments.push(doc);\n  this._monitoringUnsubscribes.push(function() {\n    // Get the window object again. When a friendly iframe is destroyed, it\n    // will be null.\n    var win = doc.defaultView;\n\n    if (win) {\n      if (monitoringInterval) {\n        win.clearInterval(monitoringInterval);\n      }\n      removeEvent(win, 'resize', callback, true);\n    }\n\n    removeEvent(doc, 'scroll', callback, true);\n    if (domObserver) {\n      domObserver.disconnect();\n    }\n  });\n\n  // Also monitor the parent.\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._monitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function(doc) {\n  var index = this._monitoringDocuments.indexOf(doc);\n  if (index == -1) {\n    return;\n  }\n\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n\n  // Check if any dependent targets are still remaining.\n  var hasDependentTargets =\n      this._observationTargets.some(function(item) {\n        var itemDoc = item.element.ownerDocument;\n        // Target is in this context.\n        if (itemDoc == doc) {\n          return true;\n        }\n        // Target is nested in this context.\n        while (itemDoc && itemDoc != rootDoc) {\n          var frame = getFrameElement(itemDoc);\n          itemDoc = frame && frame.ownerDocument;\n          if (itemDoc == doc) {\n            return true;\n          }\n        }\n        return false;\n      });\n  if (hasDependentTargets) {\n    return;\n  }\n\n  // Unsubscribe.\n  var unsubscribe = this._monitoringUnsubscribes[index];\n  this._monitoringDocuments.splice(index, 1);\n  this._monitoringUnsubscribes.splice(index, 1);\n  unsubscribe();\n\n  // Also unmonitor the parent.\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._unmonitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorAllIntersections = function() {\n  var unsubscribes = this._monitoringUnsubscribes.slice(0);\n  this._monitoringDocuments.length = 0;\n  this._monitoringUnsubscribes.length = 0;\n  for (var i = 0; i < unsubscribes.length; i++) {\n    unsubscribes[i]();\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  if (!this.root && crossOriginUpdater && !crossOriginRect) {\n    // Cross origin monitoring, but no initial data available yet.\n    return;\n  }\n\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, targetRect, rootRect);\n\n    var rootBounds = null;\n    if (!this._rootContainsTarget(target)) {\n      rootBounds = getEmptyRect();\n    } else if (!crossOriginUpdater || this.root) {\n      rootBounds = rootRect;\n    }\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootBounds,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} targetRect The bounding rect of the target.\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, targetRect, rootRect) {\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot && parent) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return null;\n\n    if (parent == this.root || parent.nodeType == /* DOCUMENT */ 9) {\n      atRoot = true;\n      if (parent == this.root || parent == document) {\n        if (crossOriginUpdater && !this.root) {\n          if (!crossOriginRect ||\n              crossOriginRect.width == 0 && crossOriginRect.height == 0) {\n            // A 0-size cross-origin intersection means no-intersection.\n            parent = null;\n            parentRect = null;\n            intersectionRect = null;\n          } else {\n            parentRect = crossOriginRect;\n          }\n        } else {\n          parentRect = rootRect;\n        }\n      } else {\n        // Check if there's a frame that can be navigated to.\n        var frame = getParentNode(parent);\n        var frameRect = frame && getBoundingClientRect(frame);\n        var frameIntersect =\n            frame &&\n            this._computeTargetAndRootIntersection(frame, frameRect, rootRect);\n        if (frameRect && frameIntersect) {\n          parent = frame;\n          parentRect = convertFromParentRect(frameRect, frameIntersect);\n        } else {\n          parent = null;\n          intersectionRect = null;\n        }\n      }\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      var doc = parent.ownerDocument;\n      if (parent != doc.body &&\n          parent != doc.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n    }\n    if (!intersectionRect) break;\n    parent = parent && getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {ClientRect} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root && !isDoc(this.root)) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var doc = isDoc(this.root) ? this.root : document;\n    var html = doc.documentElement;\n    var body = doc.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {DOMRect|ClientRect} rect The rect object to expand.\n * @return {ClientRect} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  return (\n    containsDeep(rootDoc, target) &&\n    (!this.root || rootDoc == target.ownerDocument)\n  );\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detachEvent == 'function') {\n    node.detachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object|?ClientRect} The intersection rect or undefined if no\n *     intersection is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  } || null;\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {ClientRect} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n\n/**\n * Ensure that the result has all of the necessary fields of the DOMRect.\n * Specifically this ensures that `x` and `y` fields are set.\n *\n * @param {?DOMRect|?ClientRect} rect\n * @return {?DOMRect}\n */\nfunction ensureDOMRect(rect) {\n  // A `DOMRect` object has `x` and `y` fields.\n  if (!rect || 'x' in rect) {\n    return rect;\n  }\n  // A IE's `ClientRect` type does not have `x` and `y`. The same is the case\n  // for internally calculated Rect objects. For the purposes of\n  // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`\n  // for these fields.\n  return {\n    top: rect.top,\n    y: rect.top,\n    bottom: rect.bottom,\n    left: rect.left,\n    x: rect.left,\n    right: rect.right,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\n\n/**\n * Inverts the intersection and bounding rect from the parent (frame) BCR to\n * the local BCR space.\n * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.\n * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.\n * @return {ClientRect} The local root bounding rect for the parent's children.\n */\nfunction convertFromParentRect(parentBoundingRect, parentIntersectionRect) {\n  var top = parentIntersectionRect.top - parentBoundingRect.top;\n  var left = parentIntersectionRect.left - parentBoundingRect.left;\n  return {\n    top: top,\n    left: left,\n    height: parentIntersectionRect.height,\n    width: parentIntersectionRect.width,\n    bottom: top + parentIntersectionRect.height,\n    right: left + parentIntersectionRect.width\n  };\n}\n\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (node.nodeType == /* DOCUMENT */ 9 && node != document) {\n    // If this node is a document node, look for the embedding frame.\n    return getFrameElement(node);\n  }\n\n  // If the parent has element that is assigned through shadow root slot\n  if (parent && parent.assignedSlot) {\n    parent = parent.assignedSlot.parentNode\n  }\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n\n  return parent;\n}\n\n/**\n * Returns true if `node` is a Document.\n * @param {!Node} node\n * @returns {boolean}\n */\nfunction isDoc(node) {\n  return node && node.nodeType === 9;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}());\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (Array.isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return Object.keys(obj).map(function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (Array.isArray(obj[k])) {\n        return obj[k].map(function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).filter(Boolean).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","import compute from 'compute-scroll-into-view';\nfunction isOptionsObject(options) {\n  return options === Object(options) && Object.keys(options).length !== 0;\n}\nfunction defaultBehavior(actions, behavior) {\n  if (behavior === void 0) {\n    behavior = 'auto';\n  }\n  var canSmoothScroll = ('scrollBehavior' in document.body.style);\n  actions.forEach(function (_ref) {\n    var el = _ref.el,\n      top = _ref.top,\n      left = _ref.left;\n    if (el.scroll && canSmoothScroll) {\n      el.scroll({\n        top: top,\n        left: left,\n        behavior: behavior\n      });\n    } else {\n      el.scrollTop = top;\n      el.scrollLeft = left;\n    }\n  });\n}\nfunction getOptions(options) {\n  if (options === false) {\n    return {\n      block: 'end',\n      inline: 'nearest'\n    };\n  }\n  if (isOptionsObject(options)) {\n    return options;\n  }\n  return {\n    block: 'start',\n    inline: 'nearest'\n  };\n}\nfunction scrollIntoView(target, options) {\n  var isTargetAttached = target.isConnected || target.ownerDocument.documentElement.contains(target);\n  if (isOptionsObject(options) && typeof options.behavior === 'function') {\n    return options.behavior(isTargetAttached ? compute(target, options) : []);\n  }\n  if (!isTargetAttached) {\n    return;\n  }\n  var computeOptions = getOptions(options);\n  return defaultBehavior(compute(target, computeOptions), computeOptions.behavior);\n}\nexport default scrollIntoView;"],"names":["isFunction","value","window","document","createElement","getTargetElement","target","defaultElement","current","ref","useRef","fn","fnRef","useEffect","depsAreSame","oldDeps","deps","i","length","Object","is","useEffectType","effect","hasInitRef","lastElementRef","lastDepsRef","unLoadRef","_a","els","Array","isArray","map","item","call","options","callback","option","_b","useState","state","setState","_c","ratio","setRatio","element","filter","Boolean","observer","IntersectionObserver","entries","e_1","entries_1","entries_1_1","next","done","entry","intersectionRatio","isIntersecting","e_1_1","error","return","root","forEach","el","observe","disconnect","rootMargin","threshold","IntersectionObserverEntry","prototype","defineProperty","get","this","startDoc","doc","frame","getFrameElement","ownerDocument","registry","crossOriginUpdater","crossOriginRect","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","_setupCrossOriginUpdater","boundingClientRect","intersectionRect","convertFromParentRect","top","bottom","left","right","width","height","_checkForIntersections","_resetCrossOriginUpdater","_observationTargets","some","nodeType","Error","_registerInstance","push","_monitorIntersections","unobserve","_unmonitorIntersections","_unregisterInstance","_unmonitorAllIntersections","takeRecords","records","_queuedEntries","slice","_initThresholds","opt_threshold","sort","t","a","isNaN","_parseRootMargin","opt_rootMargin","margins","split","margin","parts","exec","parseFloat","unit","win","defaultView","_monitoringDocuments","indexOf","monitoringInterval","domObserver","setInterval","addEvent","MutationObserver","attributes","childList","characterData","subtree","_monitoringUnsubscribes","clearInterval","removeEvent","rootDoc","index","hasDependentTargets","itemDoc","unsubscribe","splice","unsubscribes","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","rootBounds","newEntry","time","performance","now","_hasCrossedThreshold","_callback","getComputedStyle","display","parent","getParentNode","atRoot","parentRect","parentComputedStyle","frameRect","frameIntersect","body","documentElement","overflow","computeRectIntersection","isDoc","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","frameElement","e","ensureDOMRect","targetArea","intersectionArea","Number","toFixed","opt_options","timeout","timer","setTimeout","throttle","bind","join","node","event","opt_useCapture","addEventListener","attachEvent","removeEventListener","detachEvent","rect1","rect2","Math","max","min","err","y","x","parentBoundingRect","parentIntersectionRect","child","parentNode","assignedSlot","host","hasOwnProperty","obj","prop","module","exports","qs","sep","eq","regexp","maxKeys","len","kstr","vstr","k","v","replace","idx","substr","decodeURIComponent","stringifyPrimitive","isFinite","name","undefined","keys","ks","encodeURIComponent","decode","parse","encode","stringify","isOptionsObject","isTargetAttached","isConnected","contains","behavior","computeOptions","block","inline","getOptions","actions","canSmoothScroll","style","_ref","scroll","scrollTop","scrollLeft","defaultBehavior"],"sourceRoot":""}