{"version":3,"file":"static/chunks/6077-f302f03078595898.js","mappings":"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","sources":["webpack://_N_E/../../node_modules/@mui/icons-material/KeyboardArrowLeft.js","webpack://_N_E/../../node_modules/@mui/icons-material/KeyboardArrowRight.js","webpack://_N_E/../../node_modules/ahooks/es/useInViewport/index.js","webpack://_N_E/../../node_modules/intersection-observer/intersection-observer.js","webpack://_N_E/<anon>"],"sourcesContent":["\"use strict\";\n\"use client\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\nvar _jsxRuntime = require(\"react/jsx-runtime\");\nvar _default = exports.default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M15.41 16.59 10.83 12l4.58-4.59L14 6l-6 6 6 6z\"\n}), 'KeyboardArrowLeft');","\"use strict\";\n\"use client\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\nvar _jsxRuntime = require(\"react/jsx-runtime\");\nvar _default = exports.default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M8.59 16.59 13.17 12 8.59 7.41 10 6l6 6-6 6z\"\n}), 'KeyboardArrowRight');","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      return observer.observe(el);\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"],"names":["_interopRequireDefault","__webpack_require__","exports","Z","_createSvgIcon","_jsxRuntime","default","jsx","d","__webpack_exports__","target","options","_a","callback","option","tslib__WEBPACK_IMPORTED_MODULE_2__","_T","_b","CR","react__WEBPACK_IMPORTED_MODULE_1__","useState","state","setState","_c","ratio","setRatio","_utils_useEffectWithTarget__WEBPACK_IMPORTED_MODULE_3__","els","targets","Array","isArray","map","element","_utils_domTarget__WEBPACK_IMPORTED_MODULE_4__","n","filter","Boolean","length","observer","IntersectionObserver","entries","e_1","entries_1","XA","entries_1_1","next","done","entry","value","intersectionRatio","isIntersecting","e_1_1","error","return","call","pi","root","forEach","el","observe","disconnect","rootMargin","threshold","window","IntersectionObserverEntry","prototype","Object","defineProperty","get","document","startDoc","doc","frame","getFrameElement","ownerDocument","registry","crossOriginUpdater","crossOriginRect","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","_setupCrossOriginUpdater","boundingClientRect","intersectionRect","convertFromParentRect","getEmptyRect","_checkForIntersections","_resetCrossOriginUpdater","_observationTargets","some","item","nodeType","_registerInstance","push","_monitorIntersections","unobserve","_unmonitorIntersections","_unregisterInstance","_unmonitorAllIntersections","takeRecords","records","_queuedEntries","slice","_initThresholds","opt_threshold","sort","t","i","a","isNaN","_parseRootMargin","opt_rootMargin","margins","marginString","split","margin","parts","exec","parseFloat","unit","win","defaultView","_monitoringDocuments","indexOf","monitoringInterval","domObserver","setInterval","addEvent","MutationObserver","attributes","childList","characterData","subtree","_monitoringUnsubscribes","clearInterval","removeEvent","index","rootDoc","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","width","height","frameRect","frameIntersect","body","documentElement","overflow","computeRectIntersection","rect1","rect2","top","Math","max","bottom","min","left","right","isDoc","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","frameElement","e","ensureDOMRect","targetArea","intersectionArea","Number","toFixed","opt_options","fn","timeout","timer","bind","setTimeout","join","node","event","opt_useCapture","addEventListener","attachEvent","removeEventListener","detachEvent","err","y","x","parentBoundingRect","parentIntersectionRect","child","parentNode","assignedSlot","host"],"sourceRoot":""}