{"version":3,"sources":["webpack:///./node_modules/gsap/ScrollTrigger.js"],"names":["gsap","_coreInitted","_win","_doc","_docEl","_body","_root","_resizeDelay","_raf","_request","_toArray","_clamp","_time2","_syncInterval","_refreshing","_pointerIsDown","_transformProp","_i","_prevWidth","_prevHeight","_autoRefresh","_sort","_suppressOverwrites","_ignoreResize","_limitCallbacks","_creatingMedia","_lastMediaTick","_startup","_proxies","_scrollers","_getTime","Date","now","_time1","_lastScrollTime","_enabled","_passThrough","v","_round","value","Math","round","_windowExists","window","_getGSAP","registerPlugin","_isViewport","e","indexOf","_getProxyProp","element","property","_getScrollFunc","_ref","s","sc","i","offset","_vertical","push","arguments","length","_getBoundsFunc","_winOffsets","width","innerWidth","height","innerHeight","_getBounds","_maxScroll","_ref3","d2","d","a","max","_iterateAutoRefresh","func","events","_isString","_isFunction","_isNumber","_isObject","_callIfFunc","_combineFunc","f1","f2","result1","result2","_abs","abs","_padding","_px","_horizontal","p","p2","os","os2","scrollTo","pageXOffset","op","pageYOffset","_getComputedStyle","getComputedStyle","_setDefaults","obj","defaults","withoutTransforms","tween","to","x","y","xPercent","yPercent","rotation","rotationX","rotationY","scale","skewX","skewY","progress","bounds","getBoundingClientRect","kill","_getSize","_ref4","_getLabelRatioArray","timeline","labels","duration","_multiListener","types","callback","split","forEach","type","_addListener","addEventListener","passive","_removeListener","removeEventListener","_markerDefaults","startColor","endColor","indent","fontSize","fontWeight","_defaults","toggleActions","anticipatePin","_keywords","top","left","center","bottom","right","_offsetToPx","size","eqIndex","relative","charAt","parseFloat","substr","_createMarker","name","container","direction","_ref5","matchWidthEl","createElement","useFixedPosition","isScroller","parent","isStart","color","css","offsetWidth","_isStart","setAttribute","style","cssText","innerText","children","insertBefore","appendChild","_offset","_positionMarker","marker","start","flipped","vars","display","side","oppositeSide","_isFlipped","set","_triggers","_ids","_sync","_updateAll","_onScroll","_dispatch","_onResize","fullscreenElement","restart","_listeners","_emptyArray","_media","_onMediaChange","index","tick","ticker","frame","matches","_revertAll","matchMedia","_revertRecorded","_refreshAll","_softRefresh","ScrollTrigger","map","f","_savedStyles","media","uncache","trigger","scroll","rec","revert","force","skipRevert","refreshInits","sort","refresh","result","render","pause","_lastScroll","_direction","l","time","recordVelocity","update","_propNamesToCopy","_margin","_stateProps","concat","_swapPinIn","pin","spacer","cs","spacerState","parentNode","spacerStyle","pinStyle","position","overflow","boxSizing","_setState","_capsExp","state","t","_gsap","core","getCache","removeProperty","replace","toLowerCase","_getState","_parsePosition","scrollerSize","markerScroller","self","scrollerBounds","borderWidth","scrollerMax","localOffset","globalOffset","offsets","m","_prefixExp","_reparent","_stOrig","test","_getTweenCreator","scroller","lastScroll1","lastScroll2","getScroll","prop","getTween","initialValue","change1","change2","onComplete","modifiers","ratio","call","animation","register","console","warn","this","init","prototype","tweenTo","pinCache","snapFunc","isReverted","scroll1","scroll2","end","markerStart","markerEnd","markerStartTrigger","markerEndTrigger","markerVars","change","pinOriginalState","pinActiveState","pinState","pinGetter","pinSetter","pinStart","pinChange","spacingStart","markerStartSetter","markerEndSetter","snap1","snap2","scrubTween","scrubSmooth","snapDurClamp","snapDelayedCall","prevProgress","prevScroll","prevAnimProgress","nodeType","horizontal","_vars","onUpdate","toggleClass","id","onToggle","onRefresh","scrub","pinSpacing","invalidateOnRefresh","onScrubComplete","onSnapComplete","once","snap","pinReparent","isToggle","scrollerCache","isViewport","pinType","callbacks","onEnter","onLeave","onEnterBack","onLeaveBack","markers","onRefreshInit","getScrollerSize","_ref2","_getSizeFunc","getScrollerOffsets","_getOffsetsFunc","tweenScroll","lazy","_initted","immediateRender","scrollTrigger","ease","snapTo","scrollBehavior","utils","_getClosestLabel","st","b","pop","min","delayedCall","delay","getVelocity","totalProgress","velocity","naturalEnd","inertia","endValue","endScroll","_snap","onStart","_onInterrupt","onInterrupt","_onComplete","data","isActive","targets","className","force3D","getProperty","quickSetter","r","enabled","prevRefreshing","removeChild","_swapPinOut","soft","invalidate","isVertical","override","curTrigger","curPin","oppositeScroll","initted","otherPinOffset","parsedEnd","parsedEndTrigger","endTrigger","parsedStart","triggerIndex","_pinPush","ceil","omitOffsets","_copyState","splice","_pinOffset","reset","toggleState","action","stateChanged","toggled","clipped","el","classList","enable","add","disable","allowAnimation","document","documentElement","body","toArray","clamp","suppressOverwrites","globals","requestAnimationFrame","setTimeout","bodyStyle","border","borderTop","setInterval","checkPrefix","w","h","hidden","config","slice","limitCallbacks","ms","syncInterval","clearInterval","autoRefreshEvents","scrollerProxy","target","unshift","mq","addListener","clearMatchMedia","query","version","saveStyles","create","safe","maxScroll","getScrollFunc","getById","getAll","isScrolling","batch","varsCopy","interval","batchMax","proxyCallback","elements","triggers","refreshPriority"],"mappings":"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","file":"3.21d0a83e14e0ae522418.js","sourcesContent":["/*!\n * ScrollTrigger 3.6.1\n * https://greensock.com\n *\n * @license Copyright 2008-2021, GreenSock. All rights reserved.\n * Subject to the terms at https://greensock.com/standard-license or for\n * Club GreenSock members, the agreement issued with that membership.\n * @author: Jack Doyle, jack@greensock.com\n*/\n\n/* eslint-disable */\nvar gsap,\n    _coreInitted,\n    _win,\n    _doc,\n    _docEl,\n    _body,\n    _root,\n    _resizeDelay,\n    _raf,\n    _request,\n    _toArray,\n    _clamp,\n    _time2,\n    _syncInterval,\n    _refreshing,\n    _pointerIsDown,\n    _transformProp,\n    _i,\n    _prevWidth,\n    _prevHeight,\n    _autoRefresh,\n    _sort,\n    _suppressOverwrites,\n    _ignoreResize,\n    _limitCallbacks,\n    // if true, we'll only trigger callbacks if the active state toggles, so if you scroll immediately past both the start and end positions of a ScrollTrigger (thus inactive to inactive), neither its onEnter nor onLeave will be called. This is useful during startup.\n_startup = 1,\n    _proxies = [],\n    _scrollers = [],\n    _getTime = Date.now,\n    _time1 = _getTime(),\n    _lastScrollTime = 0,\n    _enabled = 1,\n    _passThrough = function _passThrough(v) {\n  return v;\n},\n    _round = function _round(value) {\n  return Math.round(value * 100000) / 100000 || 0;\n},\n    _windowExists = function _windowExists() {\n  return typeof window !== \"undefined\";\n},\n    _getGSAP = function _getGSAP() {\n  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;\n},\n    _isViewport = function _isViewport(e) {\n  return !!~_root.indexOf(e);\n},\n    _getProxyProp = function _getProxyProp(element, property) {\n  return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];\n},\n    _getScrollFunc = function _getScrollFunc(element, _ref) {\n  var s = _ref.s,\n      sc = _ref.sc;\n\n  var i = _scrollers.indexOf(element),\n      offset = sc === _vertical.sc ? 1 : 2;\n\n  !~i && (i = _scrollers.push(element) - 1);\n  return _scrollers[i + offset] || (_scrollers[i + offset] = _getProxyProp(element, s) || (_isViewport(element) ? sc : function (value) {\n    return arguments.length ? element[s] = value : element[s];\n  }));\n},\n    _getBoundsFunc = function _getBoundsFunc(element) {\n  return _getProxyProp(element, \"getBoundingClientRect\") || (_isViewport(element) ? function () {\n    _winOffsets.width = _win.innerWidth;\n    _winOffsets.height = _win.innerHeight;\n    return _winOffsets;\n  } : function () {\n    return _getBounds(element);\n  });\n},\n    _getSizeFunc = function _getSizeFunc(scroller, isViewport, _ref2) {\n  var d = _ref2.d,\n      d2 = _ref2.d2,\n      a = _ref2.a;\n  return (a = _getProxyProp(scroller, \"getBoundingClientRect\")) ? function () {\n    return a()[d];\n  } : function () {\n    return (isViewport ? _win[\"inner\" + d2] : scroller[\"client\" + d2]) || 0;\n  };\n},\n    _getOffsetsFunc = function _getOffsetsFunc(element, isViewport) {\n  return !isViewport || ~_proxies.indexOf(element) ? _getBoundsFunc(element) : function () {\n    return _winOffsets;\n  };\n},\n    _maxScroll = function _maxScroll(element, _ref3) {\n  var s = _ref3.s,\n      d2 = _ref3.d2,\n      d = _ref3.d,\n      a = _ref3.a;\n  return (s = \"scroll\" + d2) && (a = _getProxyProp(element, s)) ? a() - _getBoundsFunc(element)()[d] : _isViewport(element) ? Math.max(_docEl[s], _body[s]) - (_win[\"inner\" + d2] || _docEl[\"client\" + d2] || _body[\"client\" + d2]) : element[s] - element[\"offset\" + d2];\n},\n    _iterateAutoRefresh = function _iterateAutoRefresh(func, events) {\n  for (var i = 0; i < _autoRefresh.length; i += 3) {\n    (!events || ~events.indexOf(_autoRefresh[i + 1])) && func(_autoRefresh[i], _autoRefresh[i + 1], _autoRefresh[i + 2]);\n  }\n},\n    _isString = function _isString(value) {\n  return typeof value === \"string\";\n},\n    _isFunction = function _isFunction(value) {\n  return typeof value === \"function\";\n},\n    _isNumber = function _isNumber(value) {\n  return typeof value === \"number\";\n},\n    _isObject = function _isObject(value) {\n  return typeof value === \"object\";\n},\n    _callIfFunc = function _callIfFunc(value) {\n  return _isFunction(value) && value();\n},\n    _combineFunc = function _combineFunc(f1, f2) {\n  return function () {\n    var result1 = _callIfFunc(f1),\n        result2 = _callIfFunc(f2);\n\n    return function () {\n      _callIfFunc(result1);\n\n      _callIfFunc(result2);\n    };\n  };\n},\n    _abs = Math.abs,\n    _scrollLeft = \"scrollLeft\",\n    _scrollTop = \"scrollTop\",\n    _left = \"left\",\n    _top = \"top\",\n    _right = \"right\",\n    _bottom = \"bottom\",\n    _width = \"width\",\n    _height = \"height\",\n    _Right = \"Right\",\n    _Left = \"Left\",\n    _Top = \"Top\",\n    _Bottom = \"Bottom\",\n    _padding = \"padding\",\n    _margin = \"margin\",\n    _Width = \"Width\",\n    _Height = \"Height\",\n    _px = \"px\",\n    _horizontal = {\n  s: _scrollLeft,\n  p: _left,\n  p2: _Left,\n  os: _right,\n  os2: _Right,\n  d: _width,\n  d2: _Width,\n  a: \"x\",\n  sc: function sc(value) {\n    return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;\n  }\n},\n    _vertical = {\n  s: _scrollTop,\n  p: _top,\n  p2: _Top,\n  os: _bottom,\n  os2: _Bottom,\n  d: _height,\n  d2: _Height,\n  a: \"y\",\n  op: _horizontal,\n  sc: function sc(value) {\n    return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;\n  }\n},\n    _getComputedStyle = function _getComputedStyle(element) {\n  return _win.getComputedStyle(element);\n},\n    _makePositionable = function _makePositionable(element) {\n  return element.style.position = _getComputedStyle(element).position === \"absolute\" ? \"absolute\" : \"relative\";\n},\n    // if the element already has position: absolute, leave that, otherwise make it position: relative\n_setDefaults = function _setDefaults(obj, defaults) {\n  for (var p in defaults) {\n    p in obj || (obj[p] = defaults[p]);\n  }\n\n  return obj;\n},\n    //_isInViewport = element => (element = _getBounds(element)) && !(element.top > (_win.innerHeight || _docEl.clientHeight) || element.bottom < 0 || element.left > (_win.innerWidth || _docEl.clientWidth) || element.right < 0) && element,\n_getBounds = function _getBounds(element, withoutTransforms) {\n  var tween = withoutTransforms && _getComputedStyle(element)[_transformProp] !== \"matrix(1, 0, 0, 1, 0, 0)\" && gsap.to(element, {\n    x: 0,\n    y: 0,\n    xPercent: 0,\n    yPercent: 0,\n    rotation: 0,\n    rotationX: 0,\n    rotationY: 0,\n    scale: 1,\n    skewX: 0,\n    skewY: 0\n  }).progress(1),\n      bounds = element.getBoundingClientRect();\n  tween && tween.progress(0).kill();\n  return bounds;\n},\n    _getSize = function _getSize(element, _ref4) {\n  var d2 = _ref4.d2;\n  return element[\"offset\" + d2] || element[\"client\" + d2] || 0;\n},\n    _getLabelRatioArray = function _getLabelRatioArray(timeline) {\n  var a = [],\n      labels = timeline.labels,\n      duration = timeline.duration(),\n      p;\n\n  for (p in labels) {\n    a.push(labels[p] / duration);\n  }\n\n  return a;\n},\n    _getClosestLabel = function _getClosestLabel(animation) {\n  return function (value) {\n    return gsap.utils.snap(_getLabelRatioArray(animation), value);\n  };\n},\n    _getLabelAtDirection = function _getLabelAtDirection(timeline) {\n  return function (value, st) {\n    var a = _getLabelRatioArray(timeline),\n        i;\n\n    a.sort(function (a, b) {\n      return a - b;\n    });\n\n    if (st.direction > 0) {\n      value -= 1e-4; // to avoid rounding errors. If we're too strict, it might snap forward, then immediately again, and again.\n\n      for (i = 0; i < a.length; i++) {\n        if (a[i] >= value) {\n          return a[i];\n        }\n      }\n\n      return a.pop();\n    } else {\n      i = a.length;\n      value += 1e-4;\n\n      while (i--) {\n        if (a[i] <= value) {\n          return a[i];\n        }\n      }\n    }\n\n    return a[0];\n  };\n},\n    _multiListener = function _multiListener(func, element, types, callback) {\n  return types.split(\",\").forEach(function (type) {\n    return func(element, type, callback);\n  });\n},\n    _addListener = function _addListener(element, type, func) {\n  return element.addEventListener(type, func, {\n    passive: true\n  });\n},\n    _removeListener = function _removeListener(element, type, func) {\n  return element.removeEventListener(type, func);\n},\n    _markerDefaults = {\n  startColor: \"green\",\n  endColor: \"red\",\n  indent: 0,\n  fontSize: \"16px\",\n  fontWeight: \"normal\"\n},\n    _defaults = {\n  toggleActions: \"play\",\n  anticipatePin: 0\n},\n    _keywords = {\n  top: 0,\n  left: 0,\n  center: 0.5,\n  bottom: 1,\n  right: 1\n},\n    _offsetToPx = function _offsetToPx(value, size) {\n  if (_isString(value)) {\n    var eqIndex = value.indexOf(\"=\"),\n        relative = ~eqIndex ? +(value.charAt(eqIndex - 1) + 1) * parseFloat(value.substr(eqIndex + 1)) : 0;\n\n    if (~eqIndex) {\n      value.indexOf(\"%\") > eqIndex && (relative *= size / 100);\n      value = value.substr(0, eqIndex - 1);\n    }\n\n    value = relative + (value in _keywords ? _keywords[value] * size : ~value.indexOf(\"%\") ? parseFloat(value) * size / 100 : parseFloat(value) || 0);\n  }\n\n  return value;\n},\n    _createMarker = function _createMarker(type, name, container, direction, _ref5, offset, matchWidthEl) {\n  var startColor = _ref5.startColor,\n      endColor = _ref5.endColor,\n      fontSize = _ref5.fontSize,\n      indent = _ref5.indent,\n      fontWeight = _ref5.fontWeight;\n\n  var e = _doc.createElement(\"div\"),\n      useFixedPosition = _isViewport(container) || _getProxyProp(container, \"pinType\") === \"fixed\",\n      isScroller = type.indexOf(\"scroller\") !== -1,\n      parent = useFixedPosition ? _body : container,\n      isStart = type.indexOf(\"start\") !== -1,\n      color = isStart ? startColor : endColor,\n      css = \"border-color:\" + color + \";font-size:\" + fontSize + \";color:\" + color + \";font-weight:\" + fontWeight + \";pointer-events:none;white-space:nowrap;font-family:sans-serif,Arial;z-index:1000;padding:4px 8px;border-width:0;border-style:solid;\";\n\n  css += \"position:\" + (isScroller && useFixedPosition ? \"fixed;\" : \"absolute;\");\n  (isScroller || !useFixedPosition) && (css += (direction === _vertical ? _right : _bottom) + \":\" + (offset + parseFloat(indent)) + \"px;\");\n  matchWidthEl && (css += \"box-sizing:border-box;text-align:left;width:\" + matchWidthEl.offsetWidth + \"px;\");\n  e._isStart = isStart;\n  e.setAttribute(\"class\", \"gsap-marker-\" + type);\n  e.style.cssText = css;\n  e.innerText = name || name === 0 ? type + \"-\" + name : type;\n  parent.children[0] ? parent.insertBefore(e, parent.children[0]) : parent.appendChild(e);\n  e._offset = e[\"offset\" + direction.op.d2];\n\n  _positionMarker(e, 0, direction, isStart);\n\n  return e;\n},\n    _positionMarker = function _positionMarker(marker, start, direction, flipped) {\n  var vars = {\n    display: \"block\"\n  },\n      side = direction[flipped ? \"os2\" : \"p2\"],\n      oppositeSide = direction[flipped ? \"p2\" : \"os2\"];\n  marker._isFlipped = flipped;\n  vars[direction.a + \"Percent\"] = flipped ? -100 : 0;\n  vars[direction.a] = flipped ? \"1px\" : 0;\n  vars[\"border\" + side + _Width] = 1;\n  vars[\"border\" + oppositeSide + _Width] = 0;\n  vars[direction.p] = start + \"px\";\n  gsap.set(marker, vars);\n},\n    _triggers = [],\n    _ids = {},\n    _sync = function _sync() {\n  return _request || (_request = _raf(_updateAll));\n},\n    _onScroll = function _onScroll() {\n  if (!_request) {\n    _request = _raf(_updateAll);\n    _lastScrollTime || _dispatch(\"scrollStart\");\n    _lastScrollTime = _getTime();\n  }\n},\n    _onResize = function _onResize() {\n  return !_refreshing && !_ignoreResize && !_doc.fullscreenElement && _resizeDelay.restart(true);\n},\n    // ignore resizes triggered by refresh()\n_listeners = {},\n    _emptyArray = [],\n    _media = [],\n    _creatingMedia,\n    // when ScrollTrigger.matchMedia() is called, we record the current media key here (like \"(min-width: 800px)\") so that we can assign it to everything that's created during that call. Then we can revert just those when necessary. In the ScrollTrigger's init() call, the _creatingMedia is recorded as a \"media\" property on the instance.\n_lastMediaTick,\n    _onMediaChange = function _onMediaChange(e) {\n  var tick = gsap.ticker.frame,\n      matches = [],\n      i = 0,\n      index;\n\n  if (_lastMediaTick !== tick || _startup) {\n    _revertAll();\n\n    for (; i < _media.length; i += 4) {\n      index = _win.matchMedia(_media[i]).matches;\n\n      if (index !== _media[i + 3]) {\n        // note: some browsers fire the matchMedia event multiple times, like when going full screen, so we shouldn't call the function multiple times. Check to see if it's already matched.\n        _media[i + 3] = index;\n        index ? matches.push(i) : _revertAll(1, _media[i]) || _isFunction(_media[i + 2]) && _media[i + 2](); // Firefox doesn't update the \"matches\" property of the MediaQueryList object correctly - it only does so as it calls its change handler - so we must re-create a media query here to ensure it's accurate.\n      }\n    }\n\n    _revertRecorded(); // in case killing/reverting any of the animations actually added inline styles back.\n\n\n    for (i = 0; i < matches.length; i++) {\n      index = matches[i];\n      _creatingMedia = _media[index];\n      _media[index + 2] = _media[index + 1](e);\n    }\n\n    _creatingMedia = 0;\n    _coreInitted && _refreshAll(0, 1);\n    _lastMediaTick = tick;\n\n    _dispatch(\"matchMedia\");\n  }\n},\n    _softRefresh = function _softRefresh() {\n  return _removeListener(ScrollTrigger, \"scrollEnd\", _softRefresh) || _refreshAll(true);\n},\n    _dispatch = function _dispatch(type) {\n  return _listeners[type] && _listeners[type].map(function (f) {\n    return f();\n  }) || _emptyArray;\n},\n    _savedStyles = [],\n    // when ScrollTrigger.saveStyles() is called, the inline styles are recorded in this Array in a sequential format like [element, cssText, gsCache, media]. This keeps it very memory-efficient and fast to iterate through.\n_revertRecorded = function _revertRecorded(media) {\n  for (var i = 0; i < _savedStyles.length; i += 4) {\n    if (!media || _savedStyles[i + 3] === media) {\n      _savedStyles[i].style.cssText = _savedStyles[i + 1];\n      _savedStyles[i + 2].uncache = 1;\n    }\n  }\n},\n    _revertAll = function _revertAll(kill, media) {\n  var trigger;\n\n  for (_i = 0; _i < _triggers.length; _i++) {\n    trigger = _triggers[_i];\n\n    if (!media || trigger.media === media) {\n      if (kill) {\n        trigger.kill(1);\n      } else {\n        trigger.scroll.rec || (trigger.scroll.rec = trigger.scroll()); // record the scroll positions so that in each refresh() we can ensure that it doesn't shift. Remember, pinning can make things change around, especially if the same element is pinned multiple times. If one was already recorded, don't re-record because unpinning may have occurred and made it shorter.\n\n        trigger.revert();\n      }\n    }\n  }\n\n  _revertRecorded(media);\n\n  media || _dispatch(\"revert\");\n},\n    _refreshAll = function _refreshAll(force, skipRevert) {\n  if (_lastScrollTime && !force) {\n    _addListener(ScrollTrigger, \"scrollEnd\", _softRefresh);\n\n    return;\n  }\n\n  var refreshInits = _dispatch(\"refreshInit\");\n\n  _sort && ScrollTrigger.sort();\n  skipRevert || _revertAll();\n\n  for (_i = 0; _i < _triggers.length; _i++) {\n    _triggers[_i].refresh();\n  }\n\n  refreshInits.forEach(function (result) {\n    return result && result.render && result.render(-1);\n  }); // if the onRefreshInit() returns an animation (typically a gsap.set()), revert it. This makes it easy to put things in a certain spot before refreshing for measurement purposes, and then put things back.\n\n  _i = _triggers.length;\n\n  while (_i--) {\n    _triggers[_i].scroll.rec = 0;\n  }\n\n  _resizeDelay.pause();\n\n  _dispatch(\"refresh\");\n},\n    _lastScroll = 0,\n    _direction = 1,\n    _updateAll = function _updateAll() {\n  var l = _triggers.length,\n      time = _getTime(),\n      recordVelocity = time - _time1 >= 50,\n      scroll = l && _triggers[0].scroll();\n\n  _direction = _lastScroll > scroll ? -1 : 1;\n  _lastScroll = scroll;\n\n  if (recordVelocity) {\n    if (_lastScrollTime && !_pointerIsDown && time - _lastScrollTime > 200) {\n      _lastScrollTime = 0;\n\n      _dispatch(\"scrollEnd\");\n    }\n\n    _time2 = _time1;\n    _time1 = time;\n  }\n\n  if (_direction < 0) {\n    _i = l;\n\n    while (_i-- > 0) {\n      _triggers[_i] && _triggers[_i].update(0, recordVelocity);\n    }\n\n    _direction = 1;\n  } else {\n    for (_i = 0; _i < l; _i++) {\n      _triggers[_i] && _triggers[_i].update(0, recordVelocity);\n    }\n  }\n\n  _request = 0;\n},\n    _propNamesToCopy = [_left, _top, _bottom, _right, _margin + _Bottom, _margin + _Right, _margin + _Top, _margin + _Left, \"display\", \"flexShrink\", \"float\", \"zIndex\"],\n    _stateProps = _propNamesToCopy.concat([_width, _height, \"boxSizing\", \"max\" + _Width, \"max\" + _Height, \"position\", _margin, _padding, _padding + _Top, _padding + _Right, _padding + _Bottom, _padding + _Left]),\n    _swapPinOut = function _swapPinOut(pin, spacer, state) {\n  _setState(state);\n\n  if (pin.parentNode === spacer) {\n    var parent = spacer.parentNode;\n\n    if (parent) {\n      parent.insertBefore(pin, spacer);\n      parent.removeChild(spacer);\n    }\n  }\n},\n    _swapPinIn = function _swapPinIn(pin, spacer, cs, spacerState) {\n  if (pin.parentNode !== spacer) {\n    var i = _propNamesToCopy.length,\n        spacerStyle = spacer.style,\n        pinStyle = pin.style,\n        p;\n\n    while (i--) {\n      p = _propNamesToCopy[i];\n      spacerStyle[p] = cs[p];\n    }\n\n    spacerStyle.position = cs.position === \"absolute\" ? \"absolute\" : \"relative\";\n    cs.display === \"inline\" && (spacerStyle.display = \"inline-block\");\n    pinStyle[_bottom] = pinStyle[_right] = \"auto\";\n    spacerStyle.overflow = \"visible\";\n    spacerStyle.boxSizing = \"border-box\";\n    spacerStyle[_width] = _getSize(pin, _horizontal) + _px;\n    spacerStyle[_height] = _getSize(pin, _vertical) + _px;\n    spacerStyle[_padding] = pinStyle[_margin] = pinStyle[_top] = pinStyle[_left] = \"0\";\n\n    _setState(spacerState);\n\n    pinStyle[_width] = pinStyle[\"max\" + _Width] = cs[_width];\n    pinStyle[_height] = pinStyle[\"max\" + _Height] = cs[_height];\n    pinStyle[_padding] = cs[_padding];\n    pin.parentNode.insertBefore(spacer, pin);\n    spacer.appendChild(pin);\n  }\n},\n    _capsExp = /([A-Z])/g,\n    _setState = function _setState(state) {\n  if (state) {\n    var style = state.t.style,\n        l = state.length,\n        i = 0,\n        p,\n        value;\n    (state.t._gsap || gsap.core.getCache(state.t)).uncache = 1; // otherwise transforms may be off\n\n    for (; i < l; i += 2) {\n      value = state[i + 1];\n      p = state[i];\n\n      if (value) {\n        style[p] = value;\n      } else if (style[p]) {\n        style.removeProperty(p.replace(_capsExp, \"-$1\").toLowerCase());\n      }\n    }\n  }\n},\n    _getState = function _getState(element) {\n  // returns an Array with alternating values like [property, value, property, value] and a \"t\" property pointing to the target (element). Makes it fast and cheap.\n  var l = _stateProps.length,\n      style = element.style,\n      state = [],\n      i = 0;\n\n  for (; i < l; i++) {\n    state.push(_stateProps[i], style[_stateProps[i]]);\n  }\n\n  state.t = element;\n  return state;\n},\n    _copyState = function _copyState(state, override, omitOffsets) {\n  var result = [],\n      l = state.length,\n      i = omitOffsets ? 8 : 0,\n      // skip top, left, right, bottom if omitOffsets is true\n  p;\n\n  for (; i < l; i += 2) {\n    p = state[i];\n    result.push(p, p in override ? override[p] : state[i + 1]);\n  }\n\n  result.t = state.t;\n  return result;\n},\n    _winOffsets = {\n  left: 0,\n  top: 0\n},\n    _parsePosition = function _parsePosition(value, trigger, scrollerSize, direction, scroll, marker, markerScroller, self, scrollerBounds, borderWidth, useFixedPosition, scrollerMax) {\n  _isFunction(value) && (value = value(self));\n\n  if (_isString(value) && value.substr(0, 3) === \"max\") {\n    value = scrollerMax + (value.charAt(4) === \"=\" ? _offsetToPx(\"0\" + value.substr(3), scrollerSize) : 0);\n  }\n\n  if (!_isNumber(value)) {\n    _isFunction(trigger) && (trigger = trigger(self));\n\n    var element = _toArray(trigger)[0] || _body,\n        bounds = _getBounds(element) || {},\n        offsets = value.split(\" \"),\n        localOffset,\n        globalOffset,\n        display;\n\n    if ((!bounds || !bounds.left && !bounds.top) && _getComputedStyle(element).display === \"none\") {\n      // if display is \"none\", it won't report getBoundingClientRect() properly\n      display = element.style.display;\n      element.style.display = \"block\";\n      bounds = _getBounds(element);\n      display ? element.style.display = display : element.style.removeProperty(\"display\");\n    }\n\n    localOffset = _offsetToPx(offsets[0], bounds[direction.d]);\n    globalOffset = _offsetToPx(offsets[1] || \"0\", scrollerSize);\n    value = bounds[direction.p] - scrollerBounds[direction.p] - borderWidth + localOffset + scroll - globalOffset;\n    markerScroller && _positionMarker(markerScroller, globalOffset, direction, scrollerSize - globalOffset < 20 || markerScroller._isStart && globalOffset > 20);\n    scrollerSize -= scrollerSize - globalOffset; // adjust for the marker\n  } else if (markerScroller) {\n    _positionMarker(markerScroller, scrollerSize, direction, true);\n  }\n\n  if (marker) {\n    var position = value + scrollerSize,\n        isStart = marker._isStart;\n    scrollerMax = \"scroll\" + direction.d2;\n\n    _positionMarker(marker, position, direction, isStart && position > 20 || !isStart && (useFixedPosition ? Math.max(_body[scrollerMax], _docEl[scrollerMax]) : marker.parentNode[scrollerMax]) <= position + 1);\n\n    if (useFixedPosition) {\n      scrollerBounds = _getBounds(markerScroller);\n      useFixedPosition && (marker.style[direction.op.p] = scrollerBounds[direction.op.p] - direction.op.m - marker._offset + _px);\n    }\n  }\n\n  return Math.round(value);\n},\n    _prefixExp = /(?:webkit|moz|length|cssText|inset)/i,\n    _reparent = function _reparent(element, parent, top, left) {\n  if (element.parentNode !== parent) {\n    var style = element.style,\n        p,\n        cs;\n\n    if (parent === _body) {\n      element._stOrig = style.cssText; // record original inline styles so we can revert them later\n\n      cs = _getComputedStyle(element);\n\n      for (p in cs) {\n        // must copy all relevant styles to ensure that nothing changes visually when we reparent to the <body>. Skip the vendor prefixed ones.\n        if (!+p && !_prefixExp.test(p) && cs[p] && typeof style[p] === \"string\" && p !== \"0\") {\n          style[p] = cs[p];\n        }\n      }\n\n      style.top = top;\n      style.left = left;\n    } else {\n      style.cssText = element._stOrig;\n    }\n\n    gsap.core.getCache(element).uncache = 1;\n    parent.appendChild(element);\n  }\n},\n    // returns a function that can be used to tween the scroll position in the direction provided, and when doing so it'll add a .tween property to the FUNCTION itself, and remove it when the tween completes or gets killed. This gives us a way to have multiple ScrollTriggers use a central function for any given scroller and see if there's a scroll tween running (which would affect if/how things get updated)\n_getTweenCreator = function _getTweenCreator(scroller, direction) {\n  var getScroll = _getScrollFunc(scroller, direction),\n      prop = \"_scroll\" + direction.p2,\n      // add a tweenable property to the scroller that's a getter/setter function, like _scrollTop or _scrollLeft. This way, if someone does gsap.killTweensOf(scroller) it'll kill the scroll tween.\n  lastScroll1,\n      lastScroll2,\n      getTween = function getTween(scrollTo, vars, initialValue, change1, change2) {\n    var tween = getTween.tween,\n        onComplete = vars.onComplete,\n        modifiers = {};\n    tween && tween.kill();\n    lastScroll1 = Math.round(initialValue);\n    vars[prop] = scrollTo;\n    vars.modifiers = modifiers;\n\n    modifiers[prop] = function (value) {\n      value = _round(getScroll()); // round because in some [very uncommon] Windows environments, it can get reported with decimals even though it was set without.\n\n      if (value !== lastScroll1 && value !== lastScroll2 && Math.abs(value - lastScroll1) > 2) {\n        // if the user scrolls, kill the tween. iOS Safari intermittently misreports the scroll position, it may be the most recently-set one or the one before that! When Safari is zoomed (CMD-+), it often misreports as 1 pixel off too! So if we set the scroll position to 125, for example, it'll actually report it as 124.\n        tween.kill();\n        getTween.tween = 0;\n      } else {\n        value = initialValue + change1 * tween.ratio + change2 * tween.ratio * tween.ratio;\n      }\n\n      lastScroll2 = lastScroll1;\n      return lastScroll1 = _round(value);\n    };\n\n    vars.onComplete = function () {\n      getTween.tween = 0;\n      onComplete && onComplete.call(tween);\n    };\n\n    tween = getTween.tween = gsap.to(scroller, vars);\n    return tween;\n  };\n\n  scroller[prop] = getScroll;\n  scroller.addEventListener(\"wheel\", function () {\n    return getTween.tween && getTween.tween.kill() && (getTween.tween = 0);\n  }); // Windows machines handle mousewheel scrolling in chunks (like \"3 lines per scroll\") meaning the typical strategy for cancelling the scroll isn't as sensitive. It's much more likely to match one of the previous 2 scroll event positions. So we kill any snapping as soon as there's a wheel event.\n\n  return getTween;\n};\n\n_horizontal.op = _vertical;\nexport var ScrollTrigger = /*#__PURE__*/function () {\n  function ScrollTrigger(vars, animation) {\n    _coreInitted || ScrollTrigger.register(gsap) || console.warn(\"Please gsap.registerPlugin(ScrollTrigger)\");\n    this.init(vars, animation);\n  }\n\n  var _proto = ScrollTrigger.prototype;\n\n  _proto.init = function init(vars, animation) {\n    this.progress = this.start = 0;\n    this.vars && this.kill(1); // in case it's being initted again\n\n    if (!_enabled) {\n      this.update = this.refresh = this.kill = _passThrough;\n      return;\n    }\n\n    vars = _setDefaults(_isString(vars) || _isNumber(vars) || vars.nodeType ? {\n      trigger: vars\n    } : vars, _defaults);\n\n    var direction = vars.horizontal ? _horizontal : _vertical,\n        _vars = vars,\n        onUpdate = _vars.onUpdate,\n        toggleClass = _vars.toggleClass,\n        id = _vars.id,\n        onToggle = _vars.onToggle,\n        onRefresh = _vars.onRefresh,\n        scrub = _vars.scrub,\n        trigger = _vars.trigger,\n        pin = _vars.pin,\n        pinSpacing = _vars.pinSpacing,\n        invalidateOnRefresh = _vars.invalidateOnRefresh,\n        anticipatePin = _vars.anticipatePin,\n        onScrubComplete = _vars.onScrubComplete,\n        onSnapComplete = _vars.onSnapComplete,\n        once = _vars.once,\n        snap = _vars.snap,\n        pinReparent = _vars.pinReparent,\n        isToggle = !scrub && scrub !== 0,\n        scroller = _toArray(vars.scroller || _win)[0],\n        scrollerCache = gsap.core.getCache(scroller),\n        isViewport = _isViewport(scroller),\n        useFixedPosition = \"pinType\" in vars ? vars.pinType === \"fixed\" : isViewport || _getProxyProp(scroller, \"pinType\") === \"fixed\",\n        callbacks = [vars.onEnter, vars.onLeave, vars.onEnterBack, vars.onLeaveBack],\n        toggleActions = isToggle && vars.toggleActions.split(\" \"),\n        markers = \"markers\" in vars ? vars.markers : _defaults.markers,\n        borderWidth = isViewport ? 0 : parseFloat(_getComputedStyle(scroller)[\"border\" + direction.p2 + _Width]) || 0,\n        self = this,\n        onRefreshInit = vars.onRefreshInit && function () {\n      return vars.onRefreshInit(self);\n    },\n        getScrollerSize = _getSizeFunc(scroller, isViewport, direction),\n        getScrollerOffsets = _getOffsetsFunc(scroller, isViewport),\n        tweenTo,\n        pinCache,\n        snapFunc,\n        isReverted,\n        scroll1,\n        scroll2,\n        start,\n        end,\n        markerStart,\n        markerEnd,\n        markerStartTrigger,\n        markerEndTrigger,\n        markerVars,\n        change,\n        pinOriginalState,\n        pinActiveState,\n        pinState,\n        spacer,\n        offset,\n        pinGetter,\n        pinSetter,\n        pinStart,\n        pinChange,\n        spacingStart,\n        spacerState,\n        markerStartSetter,\n        markerEndSetter,\n        cs,\n        snap1,\n        snap2,\n        scrubTween,\n        scrubSmooth,\n        snapDurClamp,\n        snapDelayedCall,\n        prevProgress,\n        prevScroll,\n        prevAnimProgress;\n\n    self.media = _creatingMedia;\n    anticipatePin *= 45;\n\n    _triggers.push(self);\n\n    self.scroller = scroller;\n    self.scroll = _getScrollFunc(scroller, direction);\n    scroll1 = self.scroll();\n    self.vars = vars;\n    animation = animation || vars.animation;\n    \"refreshPriority\" in vars && (_sort = 1);\n    scrollerCache.tweenScroll = scrollerCache.tweenScroll || {\n      top: _getTweenCreator(scroller, _vertical),\n      left: _getTweenCreator(scroller, _horizontal)\n    };\n    self.tweenTo = tweenTo = scrollerCache.tweenScroll[direction.p];\n\n    if (animation) {\n      animation.vars.lazy = false;\n      animation._initted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.render(0, true, true);\n      self.animation = animation.pause();\n      animation.scrollTrigger = self;\n      scrubSmooth = _isNumber(scrub) && scrub;\n      scrubSmooth && (scrubTween = gsap.to(animation, {\n        ease: \"power3\",\n        duration: scrubSmooth,\n        onComplete: function onComplete() {\n          return onScrubComplete && onScrubComplete(self);\n        }\n      }));\n      snap1 = 0;\n      id || (id = animation.vars.id);\n    }\n\n    if (snap) {\n      _isObject(snap) || (snap = {\n        snapTo: snap\n      });\n      \"scrollBehavior\" in _body.style && gsap.set(isViewport ? [_body, _docEl] : scroller, {\n        scrollBehavior: \"auto\"\n      }); // smooth scrolling doesn't work with snap.\n\n      snapFunc = _isFunction(snap.snapTo) ? snap.snapTo : snap.snapTo === \"labels\" ? _getClosestLabel(animation) : snap.snapTo === \"labelsDirectional\" ? _getLabelAtDirection(animation) : gsap.utils.snap(snap.snapTo);\n      snapDurClamp = snap.duration || {\n        min: 0.1,\n        max: 2\n      };\n      snapDurClamp = _isObject(snapDurClamp) ? _clamp(snapDurClamp.min, snapDurClamp.max) : _clamp(snapDurClamp, snapDurClamp);\n      snapDelayedCall = gsap.delayedCall(snap.delay || scrubSmooth / 2 || 0.1, function () {\n        if (Math.abs(self.getVelocity()) < 10 && !_pointerIsDown) {\n          var totalProgress = animation && !isToggle ? animation.totalProgress() : self.progress,\n              velocity = (totalProgress - snap2) / (_getTime() - _time2) * 1000 || 0,\n              change1 = _abs(velocity / 2) * velocity / 0.185,\n              naturalEnd = totalProgress + (snap.inertia === false ? 0 : change1),\n              endValue = _clamp(0, 1, snapFunc(naturalEnd, self)),\n              scroll = self.scroll(),\n              endScroll = Math.round(start + endValue * change),\n              _snap = snap,\n              onStart = _snap.onStart,\n              _onInterrupt = _snap.onInterrupt,\n              _onComplete = _snap.onComplete,\n              tween = tweenTo.tween;\n\n          if (scroll <= end && scroll >= start && endScroll !== scroll) {\n            if (tween && !tween._initted && tween.data <= Math.abs(endScroll - scroll)) {\n              // there's an overlapping snap! So we must figure out which one is closer and let that tween live.\n              return;\n            }\n\n            tweenTo(endScroll, {\n              duration: snapDurClamp(_abs(Math.max(_abs(naturalEnd - totalProgress), _abs(endValue - totalProgress)) * 0.185 / velocity / 0.05 || 0)),\n              ease: snap.ease || \"power3\",\n              data: Math.abs(endScroll - scroll),\n              // record the distance so that if another snap tween occurs (conflict) we can prioritize the closest snap.\n              onInterrupt: function onInterrupt() {\n                return snapDelayedCall.restart(true) && _onInterrupt && _onInterrupt(self);\n              },\n              onComplete: function onComplete() {\n                snap1 = snap2 = animation && !isToggle ? animation.totalProgress() : self.progress;\n                onSnapComplete && onSnapComplete(self);\n                _onComplete && _onComplete(self);\n              }\n            }, scroll, change1 * change, endScroll - scroll - change1 * change);\n            onStart && onStart(self, tweenTo.tween);\n          }\n        } else if (self.isActive) {\n          snapDelayedCall.restart(true);\n        }\n      }).pause();\n    }\n\n    id && (_ids[id] = self);\n    trigger = self.trigger = _toArray(trigger || pin)[0];\n    pin = pin === true ? trigger : _toArray(pin)[0];\n    _isString(toggleClass) && (toggleClass = {\n      targets: trigger,\n      className: toggleClass\n    });\n\n    if (pin) {\n      pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && _getComputedStyle(pin.parentNode).display === \"flex\" ? false : _padding); // if the parent is display: flex, don't apply pinSpacing by default.\n\n      self.pin = pin;\n      vars.force3D !== false && gsap.set(pin, {\n        force3D: true\n      });\n      pinCache = gsap.core.getCache(pin);\n\n      if (!pinCache.spacer) {\n        // record the spacer and pinOriginalState on the cache in case someone tries pinning the same element with MULTIPLE ScrollTriggers - we don't want to have multiple spacers or record the \"original\" pin state after it has already been affected by another ScrollTrigger.\n        pinCache.spacer = spacer = _doc.createElement(\"div\");\n        spacer.setAttribute(\"class\", \"pin-spacer\" + (id ? \" pin-spacer-\" + id : \"\"));\n        pinCache.pinState = pinOriginalState = _getState(pin);\n      } else {\n        pinOriginalState = pinCache.pinState;\n      }\n\n      self.spacer = spacer = pinCache.spacer;\n      cs = _getComputedStyle(pin);\n      spacingStart = cs[pinSpacing + direction.os2];\n      pinGetter = gsap.getProperty(pin);\n      pinSetter = gsap.quickSetter(pin, direction.a, _px); // pin.firstChild && !_maxScroll(pin, direction) && (pin.style.overflow = \"hidden\"); // protects from collapsing margins, but can have unintended consequences as demonstrated here: https://codepen.io/GreenSock/pen/1e42c7a73bfa409d2cf1e184e7a4248d so it was removed in favor of just telling people to set up their CSS to avoid the collapsing margins (overflow: hidden | auto is just one option. Another is border-top: 1px solid transparent).\n\n      _swapPinIn(pin, spacer, cs);\n\n      pinState = _getState(pin);\n    }\n\n    if (markers) {\n      markerVars = _isObject(markers) ? _setDefaults(markers, _markerDefaults) : _markerDefaults;\n      markerStartTrigger = _createMarker(\"scroller-start\", id, scroller, direction, markerVars, 0);\n      markerEndTrigger = _createMarker(\"scroller-end\", id, scroller, direction, markerVars, 0, markerStartTrigger);\n      offset = markerStartTrigger[\"offset\" + direction.op.d2];\n      markerStart = _createMarker(\"start\", id, scroller, direction, markerVars, offset);\n      markerEnd = _createMarker(\"end\", id, scroller, direction, markerVars, offset);\n\n      if (!useFixedPosition) {\n        _makePositionable(isViewport ? _body : scroller);\n\n        gsap.set([markerStartTrigger, markerEndTrigger], {\n          force3D: true\n        });\n        markerStartSetter = gsap.quickSetter(markerStartTrigger, direction.a, _px);\n        markerEndSetter = gsap.quickSetter(markerEndTrigger, direction.a, _px);\n      }\n    }\n\n    self.revert = function (revert) {\n      var r = revert !== false || !self.enabled,\n          prevRefreshing = _refreshing;\n\n      if (r !== isReverted) {\n        if (r) {\n          prevScroll = Math.max(self.scroll(), self.scroll.rec || 0); // record the scroll so we can revert later (repositioning/pinning things can affect scroll position). In the static refresh() method, we first record all the scroll positions as a reference.\n\n          prevProgress = self.progress;\n          prevAnimProgress = animation && animation.progress();\n        }\n\n        markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {\n          return m.style.display = r ? \"none\" : \"block\";\n        });\n        r && (_refreshing = 1);\n        self.update(r); // make sure the pin is back in its original position so that all the measurements are correct.\n\n        _refreshing = prevRefreshing;\n        pin && (r ? _swapPinOut(pin, spacer, pinOriginalState) : (!pinReparent || !self.isActive) && _swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState));\n        isReverted = r;\n      }\n    };\n\n    self.refresh = function (soft, force) {\n      if ((_refreshing || !self.enabled) && !force) {\n        return;\n      }\n\n      if (pin && soft && _lastScrollTime) {\n        _addListener(ScrollTrigger, \"scrollEnd\", _softRefresh);\n\n        return;\n      }\n\n      _refreshing = 1;\n      scrubTween && scrubTween.pause();\n      invalidateOnRefresh && animation && animation.progress(0).invalidate();\n      isReverted || self.revert();\n\n      var size = getScrollerSize(),\n          scrollerBounds = getScrollerOffsets(),\n          max = _maxScroll(scroller, direction),\n          offset = 0,\n          otherPinOffset = 0,\n          parsedEnd = vars.end,\n          parsedEndTrigger = vars.endTrigger || trigger,\n          parsedStart = vars.start || (vars.start === 0 || !trigger ? 0 : pin ? \"0 0\" : \"0 100%\"),\n          triggerIndex = trigger && Math.max(0, _triggers.indexOf(self)) || 0,\n          i = triggerIndex,\n          cs,\n          bounds,\n          scroll,\n          isVertical,\n          override,\n          curTrigger,\n          curPin,\n          oppositeScroll,\n          initted;\n\n      while (i--) {\n        // user might try to pin the same element more than once, so we must find any prior triggers with the same pin, revert them, and determine how long they're pinning so that we can offset things appropriately. Make sure we revert from last to first so that things \"rewind\" properly.\n        curTrigger = _triggers[i];\n        curTrigger.end || curTrigger.refresh(0, 1) || (_refreshing = 1); // if it's a timeline-based trigger that hasn't been fully initialized yet because it's waiting for 1 tick, just force the refresh() here, otherwise if it contains a pin that's supposed to affect other ScrollTriggers further down the page, they won't be adjusted properly.\n\n        curPin = curTrigger.pin;\n        curPin && (curPin === trigger || curPin === pin) && curTrigger.revert();\n      }\n\n      start = _parsePosition(parsedStart, trigger, size, direction, self.scroll(), markerStart, markerStartTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max) || (pin ? -0.001 : 0);\n      _isFunction(parsedEnd) && (parsedEnd = parsedEnd(self));\n\n      if (_isString(parsedEnd) && !parsedEnd.indexOf(\"+=\")) {\n        if (~parsedEnd.indexOf(\" \")) {\n          parsedEnd = (_isString(parsedStart) ? parsedStart.split(\" \")[0] : \"\") + parsedEnd;\n        } else {\n          offset = _offsetToPx(parsedEnd.substr(2), size);\n          parsedEnd = _isString(parsedStart) ? parsedStart : start + offset; // _parsePosition won't factor in the offset if the start is a number, so do it here.\n\n          parsedEndTrigger = trigger;\n        }\n      }\n\n      end = Math.max(start, _parsePosition(parsedEnd || (parsedEndTrigger ? \"100% 0\" : max), parsedEndTrigger, size, direction, self.scroll() + offset, markerEnd, markerEndTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max)) || -0.001;\n      change = end - start || (start -= 0.01) && 0.001;\n      offset = 0;\n      i = triggerIndex;\n\n      while (i--) {\n        curTrigger = _triggers[i];\n        curPin = curTrigger.pin;\n\n        if (curPin && curTrigger.start - curTrigger._pinPush < start) {\n          cs = curTrigger.end - curTrigger.start;\n          curPin === trigger && (offset += cs);\n          curPin === pin && (otherPinOffset += cs);\n        }\n      }\n\n      start += offset;\n      end += offset;\n      self._pinPush = otherPinOffset;\n\n      if (markerStart && offset) {\n        // offset the markers if necessary\n        cs = {};\n        cs[direction.a] = \"+=\" + offset;\n        gsap.set([markerStart, markerEnd], cs);\n      }\n\n      if (pin) {\n        cs = _getComputedStyle(pin);\n        isVertical = direction === _vertical;\n        scroll = self.scroll(); // recalculate because the triggers can affect the scroll\n\n        pinStart = parseFloat(pinGetter(direction.a)) + otherPinOffset;\n        !max && end > 1 && ((isViewport ? _body : scroller).style[\"overflow-\" + direction.a] = \"scroll\"); // makes sure the scroller has a scrollbar, otherwise if something has width: 100%, for example, it would be too big (exclude the scrollbar). See https://greensock.com/forums/topic/25182-scrolltrigger-width-of-page-increase-where-markers-are-set-to-false/\n\n        _swapPinIn(pin, spacer, cs);\n\n        pinState = _getState(pin); // transforms will interfere with the top/left/right/bottom placement, so remove them temporarily. getBoundingClientRect() factors in transforms.\n\n        bounds = _getBounds(pin, true);\n        oppositeScroll = useFixedPosition && _getScrollFunc(scroller, isVertical ? _horizontal : _vertical)();\n\n        if (pinSpacing) {\n          spacerState = [pinSpacing + direction.os2, change + otherPinOffset + _px];\n          spacerState.t = spacer;\n          i = pinSpacing === _padding ? _getSize(pin, direction) + change + otherPinOffset : 0;\n          i && spacerState.push(direction.d, i + _px); // for box-sizing: border-box (must include padding).\n\n          _setState(spacerState);\n\n          useFixedPosition && self.scroll(prevScroll);\n        }\n\n        if (useFixedPosition) {\n          override = {\n            top: bounds.top + (isVertical ? scroll - start : oppositeScroll) + _px,\n            left: bounds.left + (isVertical ? oppositeScroll : scroll - start) + _px,\n            boxSizing: \"border-box\",\n            position: \"fixed\"\n          };\n          override[_width] = override[\"max\" + _Width] = Math.ceil(bounds.width) + _px;\n          override[_height] = override[\"max\" + _Height] = Math.ceil(bounds.height) + _px;\n          override[_margin] = override[_margin + _Top] = override[_margin + _Right] = override[_margin + _Bottom] = override[_margin + _Left] = \"0\";\n          override[_padding] = cs[_padding];\n          override[_padding + _Top] = cs[_padding + _Top];\n          override[_padding + _Right] = cs[_padding + _Right];\n          override[_padding + _Bottom] = cs[_padding + _Bottom];\n          override[_padding + _Left] = cs[_padding + _Left];\n          pinActiveState = _copyState(pinOriginalState, override, pinReparent);\n        }\n\n        if (animation) {\n          // the animation might be affecting the transform, so we must jump to the end, check the value, and compensate accordingly. Otherwise, when it becomes unpinned, the pinSetter() will get set to a value that doesn't include whatever the animation did.\n          initted = animation._initted; // if not, we must invalidate() after this step, otherwise it could lock in starting values prematurely.\n\n          _suppressOverwrites(1);\n\n          animation.progress(1, true);\n          pinChange = pinGetter(direction.a) - pinStart + change + otherPinOffset;\n          change !== pinChange && pinActiveState.splice(pinActiveState.length - 2, 2); // transform is the last property/value set in the state Array. Since the animation is controlling that, we should omit it.\n\n          animation.progress(0, true);\n          initted || animation.invalidate();\n\n          _suppressOverwrites(0);\n        } else {\n          pinChange = change;\n        }\n      } else if (trigger && self.scroll()) {\n        // it may be INSIDE a pinned element, so walk up the tree and look for any elements with _pinOffset to compensate because anything with pinSpacing that's already scrolled would throw off the measurements in getBoundingClientRect()\n        bounds = trigger.parentNode;\n\n        while (bounds && bounds !== _body) {\n          if (bounds._pinOffset) {\n            start -= bounds._pinOffset;\n            end -= bounds._pinOffset;\n          }\n\n          bounds = bounds.parentNode;\n        }\n      }\n\n      for (i = 0; i < triggerIndex; i++) {\n        // make sure we revert from first to last to make sure things reach their end state properly\n        curTrigger = _triggers[i].pin;\n        curTrigger && (curTrigger === trigger || curTrigger === pin) && _triggers[i].revert(false);\n      }\n\n      self.start = start;\n      self.end = end;\n      scroll1 = scroll2 = self.scroll(); // reset velocity\n\n      scroll1 < prevScroll && self.scroll(prevScroll);\n      self.revert(false);\n      _refreshing = 0;\n      animation && isToggle && animation._initted && animation.progress(prevAnimProgress, true).render(animation.time(), true, true); // must force a re-render because if saveStyles() was used on the target(s), the styles could have been wiped out during the refresh().\n\n      if (prevProgress !== self.progress) {\n        // ensures that the direction is set properly (when refreshing, progress is set back to 0 initially, then back again to wherever it needs to be) and that callbacks are triggered.\n        scrubTween && animation.totalProgress(prevProgress, true); // to avoid issues where animation callbacks like onStart aren't triggered.\n\n        self.progress = prevProgress;\n        self.update();\n      }\n\n      pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange));\n      onRefresh && onRefresh(self);\n    };\n\n    self.getVelocity = function () {\n      return (self.scroll() - scroll2) / (_getTime() - _time2) * 1000 || 0;\n    };\n\n    self.update = function (reset, recordVelocity) {\n      var scroll = self.scroll(),\n          p = reset ? 0 : (scroll - start) / change,\n          clipped = p < 0 ? 0 : p > 1 ? 1 : p || 0,\n          prevProgress = self.progress,\n          isActive,\n          wasActive,\n          toggleState,\n          action,\n          stateChanged,\n          toggled;\n\n      if (recordVelocity) {\n        scroll2 = scroll1;\n        scroll1 = scroll;\n\n        if (snap) {\n          snap2 = snap1;\n          snap1 = animation && !isToggle ? animation.totalProgress() : clipped;\n        }\n      } // anticipate the pinning a few ticks ahead of time based on velocity to avoid a visual glitch due to the fact that most browsers do scrolling on a separate thread (not synced with requestAnimationFrame).\n\n\n      anticipatePin && !clipped && pin && !_refreshing && !_startup && _lastScrollTime && start < scroll + (scroll - scroll2) / (_getTime() - _time2) * anticipatePin && (clipped = 0.0001);\n\n      if (clipped !== prevProgress && self.enabled) {\n        isActive = self.isActive = !!clipped && clipped < 1;\n        wasActive = !!prevProgress && prevProgress < 1;\n        toggled = isActive !== wasActive;\n        stateChanged = toggled || !!clipped !== !!prevProgress; // could go from start all the way to end, thus it didn't toggle but it did change state in a sense (may need to fire a callback)\n\n        self.direction = clipped > prevProgress ? 1 : -1;\n        self.progress = clipped;\n\n        if (!isToggle) {\n          if (scrubTween && !_refreshing && !_startup) {\n            scrubTween.vars.totalProgress = clipped;\n            scrubTween.invalidate().restart();\n          } else if (animation) {\n            animation.totalProgress(clipped, !!_refreshing);\n          }\n        }\n\n        if (pin) {\n          reset && pinSpacing && (spacer.style[pinSpacing + direction.os2] = spacingStart);\n\n          if (!useFixedPosition) {\n            pinSetter(pinStart + pinChange * clipped);\n          } else if (stateChanged) {\n            action = !reset && clipped > prevProgress && end + 1 > scroll && scroll + 1 >= _maxScroll(scroller, direction); // if it's at the VERY end of the page, don't switch away from position: fixed because it's pointless and it could cause a brief flash when the user scrolls back up (when it gets pinned again)\n\n            if (pinReparent) {\n              if (!reset && (isActive || action)) {\n                var bounds = _getBounds(pin, true),\n                    _offset = scroll - start;\n\n                _reparent(pin, _body, bounds.top + (direction === _vertical ? _offset : 0) + _px, bounds.left + (direction === _vertical ? 0 : _offset) + _px);\n              } else {\n                _reparent(pin, spacer);\n              }\n            }\n\n            _setState(isActive || action ? pinActiveState : pinState);\n\n            pinChange !== change && clipped < 1 && isActive || pinSetter(pinStart + (clipped === 1 && !action ? pinChange : 0));\n          }\n        }\n\n        snap && !tweenTo.tween && !_refreshing && !_startup && snapDelayedCall.restart(true);\n        toggleClass && (toggled || once && clipped && (clipped < 1 || !_limitCallbacks)) && _toArray(toggleClass.targets).forEach(function (el) {\n          return el.classList[isActive || once ? \"add\" : \"remove\"](toggleClass.className);\n        }); // classes could affect positioning, so do it even if reset or refreshing is true.\n\n        onUpdate && !isToggle && !reset && onUpdate(self);\n\n        if (stateChanged && !_refreshing) {\n          toggleState = clipped && !prevProgress ? 0 : clipped === 1 ? 1 : prevProgress === 1 ? 2 : 3; // 0 = enter, 1 = leave, 2 = enterBack, 3 = leaveBack (we prioritize the FIRST encounter, thus if you scroll really fast past the onEnter and onLeave in one tick, it'd prioritize onEnter.\n\n          if (isToggle) {\n            action = !toggled && toggleActions[toggleState + 1] !== \"none\" && toggleActions[toggleState + 1] || toggleActions[toggleState]; // if it didn't toggle, that means it shot right past and since we prioritize the \"enter\" action, we should switch to the \"leave\" in this case (but only if one is defined)\n\n            if (animation && (action === \"complete\" || action === \"reset\" || action in animation)) {\n              if (action === \"complete\") {\n                animation.pause().totalProgress(1);\n              } else if (action === \"reset\") {\n                animation.restart(true).pause();\n              } else {\n                animation[action]();\n              }\n            }\n\n            onUpdate && onUpdate(self);\n          }\n\n          if (toggled || !_limitCallbacks) {\n            // on startup, the page could be scrolled and we don't want to fire callbacks that didn't toggle. For example onEnter shouldn't fire if the ScrollTrigger isn't actually entered.\n            onToggle && toggled && onToggle(self);\n            callbacks[toggleState] && callbacks[toggleState](self);\n            once && (clipped === 1 ? self.kill(false, 1) : callbacks[toggleState] = 0); // a callback shouldn't be called again if once is true.\n\n            if (!toggled) {\n              // it's possible to go completely past, like from before the start to after the end (or vice-versa) in which case BOTH callbacks should be fired in that order\n              toggleState = clipped === 1 ? 1 : 3;\n              callbacks[toggleState] && callbacks[toggleState](self);\n            }\n          }\n        } else if (isToggle && onUpdate && !_refreshing) {\n          onUpdate(self);\n        }\n      } // update absolutely-positioned markers (only if the scroller isn't the viewport)\n\n\n      if (markerEndSetter) {\n        markerStartSetter(scroll + (markerStartTrigger._isFlipped ? 1 : 0));\n        markerEndSetter(scroll);\n      }\n    };\n\n    self.enable = function () {\n      if (!self.enabled) {\n        self.enabled = true;\n\n        _addListener(scroller, \"resize\", _onResize);\n\n        _addListener(scroller, \"scroll\", _onScroll);\n\n        onRefreshInit && _addListener(ScrollTrigger, \"refreshInit\", onRefreshInit);\n        !animation || !animation.add ? self.refresh() : gsap.delayedCall(0.01, function () {\n          return start || end || self.refresh();\n        }) && (change = 0.01) && (start = end = 0); // if the animation is a timeline, it may not have been populated yet, so it wouldn't render at the proper place on the first refresh(), thus we should schedule one for the next tick.\n      }\n    };\n\n    self.disable = function (reset, allowAnimation) {\n      if (self.enabled) {\n        reset !== false && self.revert();\n        self.enabled = self.isActive = false;\n        allowAnimation || scrubTween && scrubTween.pause();\n        prevScroll = 0;\n        pinCache && (pinCache.uncache = 1);\n        onRefreshInit && _removeListener(ScrollTrigger, \"refreshInit\", onRefreshInit);\n\n        if (snapDelayedCall) {\n          snapDelayedCall.pause();\n          tweenTo.tween && tweenTo.tween.kill() && (tweenTo.tween = 0);\n        }\n\n        if (!isViewport) {\n          var i = _triggers.length;\n\n          while (i--) {\n            if (_triggers[i].scroller === scroller && _triggers[i] !== self) {\n              return; //don't remove the listeners if there are still other triggers referencing it.\n            }\n          }\n\n          _removeListener(scroller, \"resize\", _onResize);\n\n          _removeListener(scroller, \"scroll\", _onScroll);\n        }\n      }\n    };\n\n    self.kill = function (revert, allowAnimation) {\n      self.disable(revert, allowAnimation);\n      id && delete _ids[id];\n\n      var i = _triggers.indexOf(self);\n\n      _triggers.splice(i, 1);\n\n      i === _i && _direction > 0 && _i--; // if we're in the middle of a refresh() or update(), splicing would cause skips in the index, so adjust...\n\n      if (animation) {\n        animation.scrollTrigger = null;\n        revert && animation.render(-1);\n        allowAnimation || animation.kill();\n      }\n\n      markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {\n        return m.parentNode.removeChild(m);\n      });\n\n      if (pin) {\n        pinCache && (pinCache.uncache = 1);\n        i = 0;\n\n        _triggers.forEach(function (t) {\n          return t.pin === pin && i++;\n        });\n\n        i || (pinCache.spacer = 0); // if there aren't any more ScrollTriggers with the same pin, remove the spacer, otherwise it could be contaminated with old/stale values if the user re-creates a ScrollTrigger for the same element.\n      }\n    };\n\n    self.enable();\n  };\n\n  ScrollTrigger.register = function register(core) {\n    if (!_coreInitted) {\n      gsap = core || _getGSAP();\n\n      if (_windowExists() && window.document) {\n        _win = window;\n        _doc = document;\n        _docEl = _doc.documentElement;\n        _body = _doc.body;\n      }\n\n      if (gsap) {\n        _toArray = gsap.utils.toArray;\n        _clamp = gsap.utils.clamp;\n        _suppressOverwrites = gsap.core.suppressOverwrites || _passThrough;\n        gsap.core.globals(\"ScrollTrigger\", ScrollTrigger); // must register the global manually because in Internet Explorer, functions (classes) don't have a \"name\" property.\n\n        if (_body) {\n          _raf = _win.requestAnimationFrame || function (f) {\n            return setTimeout(f, 16);\n          };\n\n          _addListener(_win, \"wheel\", _onScroll);\n\n          _root = [_win, _doc, _docEl, _body];\n\n          _addListener(_doc, \"scroll\", _onScroll); // some browsers (like Chrome), the window stops dispatching scroll events on the window if you scroll really fast, but it's consistent on the document!\n\n\n          var bodyStyle = _body.style,\n              border = bodyStyle.borderTop,\n              bounds;\n          bodyStyle.borderTop = \"1px solid #000\"; // works around an issue where a margin of a child element could throw off the bounds of the _body, making it seem like there's a margin when there actually isn't. The border ensures that the bounds are accurate.\n\n          bounds = _getBounds(_body);\n          _vertical.m = Math.round(bounds.top + _vertical.sc()) || 0; // accommodate the offset of the <body> caused by margins and/or padding\n\n          _horizontal.m = Math.round(bounds.left + _horizontal.sc()) || 0;\n          border ? bodyStyle.borderTop = border : bodyStyle.removeProperty(\"border-top\");\n          _syncInterval = setInterval(_sync, 200);\n          gsap.delayedCall(0.5, function () {\n            return _startup = 0;\n          });\n\n          _addListener(_doc, \"touchcancel\", _passThrough); // some older Android devices intermittently stop dispatching \"touchmove\" events if we don't listen for \"touchcancel\" on the document.\n\n\n          _addListener(_body, \"touchstart\", _passThrough); //works around Safari bug: https://greensock.com/forums/topic/21450-draggable-in-iframe-on-mobile-is-buggy/\n\n\n          _multiListener(_addListener, _doc, \"pointerdown,touchstart,mousedown\", function () {\n            return _pointerIsDown = 1;\n          });\n\n          _multiListener(_addListener, _doc, \"pointerup,touchend,mouseup\", function () {\n            return _pointerIsDown = 0;\n          });\n\n          _transformProp = gsap.utils.checkPrefix(\"transform\");\n\n          _stateProps.push(_transformProp);\n\n          _coreInitted = _getTime();\n          _resizeDelay = gsap.delayedCall(0.2, _refreshAll).pause();\n          _autoRefresh = [_doc, \"visibilitychange\", function () {\n            var w = _win.innerWidth,\n                h = _win.innerHeight;\n\n            if (_doc.hidden) {\n              _prevWidth = w;\n              _prevHeight = h;\n            } else if (_prevWidth !== w || _prevHeight !== h) {\n              _onResize();\n            }\n          }, _doc, \"DOMContentLoaded\", _refreshAll, _win, \"load\", function () {\n            return _lastScrollTime || _refreshAll();\n          }, _win, \"resize\", _onResize];\n\n          _iterateAutoRefresh(_addListener);\n        }\n      }\n    }\n\n    return _coreInitted;\n  };\n\n  ScrollTrigger.defaults = function defaults(config) {\n    for (var p in config) {\n      _defaults[p] = config[p];\n    }\n  };\n\n  ScrollTrigger.kill = function kill() {\n    _enabled = 0;\n\n    _triggers.slice(0).forEach(function (trigger) {\n      return trigger.kill(1);\n    });\n  };\n\n  ScrollTrigger.config = function config(vars) {\n    \"limitCallbacks\" in vars && (_limitCallbacks = !!vars.limitCallbacks);\n    var ms = vars.syncInterval;\n    ms && clearInterval(_syncInterval) || (_syncInterval = ms) && setInterval(_sync, ms);\n\n    if (\"autoRefreshEvents\" in vars) {\n      _iterateAutoRefresh(_removeListener) || _iterateAutoRefresh(_addListener, vars.autoRefreshEvents || \"none\");\n      _ignoreResize = (vars.autoRefreshEvents + \"\").indexOf(\"resize\") === -1;\n    }\n  };\n\n  ScrollTrigger.scrollerProxy = function scrollerProxy(target, vars) {\n    var t = _toArray(target)[0],\n        i = _scrollers.indexOf(t),\n        isViewport = _isViewport(t);\n\n    if (~i) {\n      _scrollers.splice(i, isViewport ? 6 : 2);\n    }\n\n    isViewport ? _proxies.unshift(_win, vars, _body, vars, _docEl, vars) : _proxies.unshift(t, vars);\n  };\n\n  ScrollTrigger.matchMedia = function matchMedia(vars) {\n    // _media is populated in the following order: mediaQueryString, onMatch, onUnmatch, isMatched. So if there are two media queries, the Array would have a length of 8\n    var mq, p, i, func, result;\n\n    for (p in vars) {\n      i = _media.indexOf(p);\n      func = vars[p];\n      _creatingMedia = p;\n\n      if (p === \"all\") {\n        func();\n      } else {\n        mq = _win.matchMedia(p);\n\n        if (mq) {\n          mq.matches && (result = func());\n\n          if (~i) {\n            _media[i + 1] = _combineFunc(_media[i + 1], func);\n            _media[i + 2] = _combineFunc(_media[i + 2], result);\n          } else {\n            i = _media.length;\n\n            _media.push(p, func, result);\n\n            mq.addListener ? mq.addListener(_onMediaChange) : mq.addEventListener(\"change\", _onMediaChange);\n          }\n\n          _media[i + 3] = mq.matches;\n        }\n      }\n\n      _creatingMedia = 0;\n    }\n\n    return _media;\n  };\n\n  ScrollTrigger.clearMatchMedia = function clearMatchMedia(query) {\n    query || (_media.length = 0);\n    query = _media.indexOf(query);\n    query >= 0 && _media.splice(query, 4);\n  };\n\n  return ScrollTrigger;\n}();\nScrollTrigger.version = \"3.6.1\";\n\nScrollTrigger.saveStyles = function (targets) {\n  return targets ? _toArray(targets).forEach(function (target) {\n    if (target && target.style) {\n      var i = _savedStyles.indexOf(target);\n\n      i >= 0 && _savedStyles.splice(i, 4);\n\n      _savedStyles.push(target, target.style.cssText, gsap.core.getCache(target), _creatingMedia);\n    }\n  }) : _savedStyles;\n};\n\nScrollTrigger.revert = function (soft, media) {\n  return _revertAll(!soft, media);\n};\n\nScrollTrigger.create = function (vars, animation) {\n  return new ScrollTrigger(vars, animation);\n};\n\nScrollTrigger.refresh = function (safe) {\n  return safe ? _onResize() : _refreshAll(true);\n};\n\nScrollTrigger.update = _updateAll;\n\nScrollTrigger.maxScroll = function (element, horizontal) {\n  return _maxScroll(element, horizontal ? _horizontal : _vertical);\n};\n\nScrollTrigger.getScrollFunc = function (element, horizontal) {\n  return _getScrollFunc(_toArray(element)[0], horizontal ? _horizontal : _vertical);\n};\n\nScrollTrigger.getById = function (id) {\n  return _ids[id];\n};\n\nScrollTrigger.getAll = function () {\n  return _triggers.slice(0);\n};\n\nScrollTrigger.isScrolling = function () {\n  return !!_lastScrollTime;\n};\n\nScrollTrigger.addEventListener = function (type, callback) {\n  var a = _listeners[type] || (_listeners[type] = []);\n  ~a.indexOf(callback) || a.push(callback);\n};\n\nScrollTrigger.removeEventListener = function (type, callback) {\n  var a = _listeners[type],\n      i = a && a.indexOf(callback);\n  i >= 0 && a.splice(i, 1);\n};\n\nScrollTrigger.batch = function (targets, vars) {\n  var result = [],\n      varsCopy = {},\n      interval = vars.interval || 0.016,\n      batchMax = vars.batchMax || 1e9,\n      proxyCallback = function proxyCallback(type, callback) {\n    var elements = [],\n        triggers = [],\n        delay = gsap.delayedCall(interval, function () {\n      callback(elements, triggers);\n      elements = [];\n      triggers = [];\n    }).pause();\n    return function (self) {\n      elements.length || delay.restart(true);\n      elements.push(self.trigger);\n      triggers.push(self);\n      batchMax <= elements.length && delay.progress(1);\n    };\n  },\n      p;\n\n  for (p in vars) {\n    varsCopy[p] = p.substr(0, 2) === \"on\" && _isFunction(vars[p]) && p !== \"onRefreshInit\" ? proxyCallback(p, vars[p]) : vars[p];\n  }\n\n  if (_isFunction(batchMax)) {\n    batchMax = batchMax();\n\n    _addListener(ScrollTrigger, \"refresh\", function () {\n      return batchMax = vars.batchMax();\n    });\n  }\n\n  _toArray(targets).forEach(function (target) {\n    var config = {};\n\n    for (p in varsCopy) {\n      config[p] = varsCopy[p];\n    }\n\n    config.trigger = target;\n    result.push(ScrollTrigger.create(config));\n  });\n\n  return result;\n};\n\nScrollTrigger.sort = function (func) {\n  return _triggers.sort(func || function (a, b) {\n    return (a.vars.refreshPriority || 0) * -1e6 + a.start - (b.start + (b.vars.refreshPriority || 0) * -1e6);\n  });\n};\n\n_getGSAP() && gsap.registerPlugin(ScrollTrigger);\nexport { ScrollTrigger as default };"],"sourceRoot":""}