component---src-pages-index-tsx-d53e36ce4647de2b95fc.js.map

{"version":3,"file":"component---src-pages-index-tsx-d53e36ce4647de2b95fc.js","mappings":"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","sources":["webpack://my-gatsby-site/./src/layouts/index.tsx","webpack://my-gatsby-site/./node_modules/gsap/CSSPlugin.js","webpack://my-gatsby-site/./node_modules/gsap/index.js","webpack://my-gatsby-site/./node_modules/gsap/Observer.js","webpack://my-gatsby-site/./node_modules/gsap/ScrollTrigger.js","webpack://my-gatsby-site/./src/components/ContactCard.tsx","webpack://my-gatsby-site/./src/components/Hero.tsx","webpack://my-gatsby-site/./src/components/Project.tsx","webpack://my-gatsby-site/./src/components/Projects.tsx","webpack://my-gatsby-site/./src/components/ChallengeCard.tsx","webpack://my-gatsby-site/./src/components/Challenge.tsx","webpack://my-gatsby-site/./src/pages/index.tsx","webpack://my-gatsby-site/./node_modules/lodash/_Symbol.js","webpack://my-gatsby-site/./node_modules/lodash/_baseGetTag.js","webpack://my-gatsby-site/./node_modules/lodash/_baseTrim.js","webpack://my-gatsby-site/./node_modules/lodash/_freeGlobal.js","webpack://my-gatsby-site/./node_modules/lodash/_getRawTag.js","webpack://my-gatsby-site/./node_modules/lodash/_objectToString.js","webpack://my-gatsby-site/./node_modules/lodash/_root.js","webpack://my-gatsby-site/./node_modules/lodash/_trimmedEndIndex.js","webpack://my-gatsby-site/./node_modules/lodash/debounce.js","webpack://my-gatsby-site/./node_modules/lodash/isObject.js","webpack://my-gatsby-site/./node_modules/lodash/isObjectLike.js","webpack://my-gatsby-site/./node_modules/lodash/isSymbol.js","webpack://my-gatsby-site/./node_modules/lodash/now.js","webpack://my-gatsby-site/./node_modules/lodash/toNumber.js"],"sourcesContent":["import React from \"react\";\r\nimport Helmet from \"react-helmet\";\r\n\r\n// Define types for the props\r\ninterface LayoutProps {\r\n  children: React.ReactNode;\r\n  data: {\r\n    name: string;\r\n    summary: string;\r\n  };\r\n}\r\n\r\nconst Layout: React.FC<LayoutProps> = ({ children, data }) => (\r\n  <div className=\"bg-gray-300\">\r\n    <Helmet\r\n      title={data.name}\r\n      meta={[\r\n        {\r\n          name: \"description\",\r\n          content: data.summary,\r\n        },\r\n        { name: \"keywords\", content: \"frontend dev, react, blog\" },\r\n      ]}\r\n    />\r\n    <link\r\n      rel=\"stylesheet\"\r\n      href=\"https://fonts.googleapis.com/css?family=Fira+Sans:400,400i,600,600i\"\r\n    />\r\n    <div>{children}</div>\r\n  </div>\r\n);\r\n\r\nexport default Layout;\r\n","/*!\n * CSSPlugin 3.12.5\n * https://gsap.com\n *\n * Copyright 2008-2024, GreenSock. All rights reserved.\n * Subject to the terms at https://gsap.com/standard-license or for\n * Club GSAP members, the agreement issued with that membership.\n * @author: Jack Doyle, jack@greensock.com\n*/\n\n/* eslint-disable */\nimport { gsap, _getProperty, _numExp, _numWithUnitExp, getUnit, _isString, _isUndefined, _renderComplexString, _relExp, _forEachName, _sortPropTweensByPriority, _colorStringFilter, _checkPlugin, _replaceRandom, _plugins, GSCache, PropTween, _config, _ticker, _round, _missingPlugin, _getSetter, _getCache, _colorExp, _parseRelative, _setDefaults, _removeLinkedListItem //for the commented-out className feature.\n} from \"./gsap-core.js\";\n\nvar _win,\n    _doc,\n    _docElement,\n    _pluginInitted,\n    _tempDiv,\n    _tempDivStyler,\n    _recentSetterPlugin,\n    _reverting,\n    _windowExists = function _windowExists() {\n  return typeof window !== \"undefined\";\n},\n    _transformProps = {},\n    _RAD2DEG = 180 / Math.PI,\n    _DEG2RAD = Math.PI / 180,\n    _atan2 = Math.atan2,\n    _bigNum = 1e8,\n    _capsExp = /([A-Z])/g,\n    _horizontalExp = /(left|right|width|margin|padding|x)/i,\n    _complexExp = /[\\s,\\(]\\S/,\n    _propertyAliases = {\n  autoAlpha: \"opacity,visibility\",\n  scale: \"scaleX,scaleY\",\n  alpha: \"opacity\"\n},\n    _renderCSSProp = function _renderCSSProp(ratio, data) {\n  return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);\n},\n    _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {\n  return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);\n},\n    _renderCSSPropWithBeginning = function _renderCSSPropWithBeginning(ratio, data) {\n  return data.set(data.t, data.p, ratio ? Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u : data.b, data);\n},\n    //if units change, we need a way to render the original unit/value when the tween goes all the way back to the beginning (ratio:0)\n_renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {\n  var value = data.s + data.c * ratio;\n  data.set(data.t, data.p, ~~(value + (value < 0 ? -.5 : .5)) + data.u, data);\n},\n    _renderNonTweeningValue = function _renderNonTweeningValue(ratio, data) {\n  return data.set(data.t, data.p, ratio ? data.e : data.b, data);\n},\n    _renderNonTweeningValueOnlyAtEnd = function _renderNonTweeningValueOnlyAtEnd(ratio, data) {\n  return data.set(data.t, data.p, ratio !== 1 ? data.b : data.e, data);\n},\n    _setterCSSStyle = function _setterCSSStyle(target, property, value) {\n  return target.style[property] = value;\n},\n    _setterCSSProp = function _setterCSSProp(target, property, value) {\n  return target.style.setProperty(property, value);\n},\n    _setterTransform = function _setterTransform(target, property, value) {\n  return target._gsap[property] = value;\n},\n    _setterScale = function _setterScale(target, property, value) {\n  return target._gsap.scaleX = target._gsap.scaleY = value;\n},\n    _setterScaleWithRender = function _setterScaleWithRender(target, property, value, data, ratio) {\n  var cache = target._gsap;\n  cache.scaleX = cache.scaleY = value;\n  cache.renderTransform(ratio, cache);\n},\n    _setterTransformWithRender = function _setterTransformWithRender(target, property, value, data, ratio) {\n  var cache = target._gsap;\n  cache[property] = value;\n  cache.renderTransform(ratio, cache);\n},\n    _transformProp = \"transform\",\n    _transformOriginProp = _transformProp + \"Origin\",\n    _saveStyle = function _saveStyle(property, isNotCSS) {\n  var _this = this;\n\n  var target = this.target,\n      style = target.style,\n      cache = target._gsap;\n\n  if (property in _transformProps && style) {\n    this.tfm = this.tfm || {};\n\n    if (property !== \"transform\") {\n      property = _propertyAliases[property] || property;\n      ~property.indexOf(\",\") ? property.split(\",\").forEach(function (a) {\n        return _this.tfm[a] = _get(target, a);\n      }) : this.tfm[property] = cache.x ? cache[property] : _get(target, property); // note: scale would map to \"scaleX,scaleY\", thus we loop and apply them both.\n\n      property === _transformOriginProp && (this.tfm.zOrigin = cache.zOrigin);\n    } else {\n      return _propertyAliases.transform.split(\",\").forEach(function (p) {\n        return _saveStyle.call(_this, p, isNotCSS);\n      });\n    }\n\n    if (this.props.indexOf(_transformProp) >= 0) {\n      return;\n    }\n\n    if (cache.svg) {\n      this.svgo = target.getAttribute(\"data-svg-origin\");\n      this.props.push(_transformOriginProp, isNotCSS, \"\");\n    }\n\n    property = _transformProp;\n  }\n\n  (style || isNotCSS) && this.props.push(property, isNotCSS, style[property]);\n},\n    _removeIndependentTransforms = function _removeIndependentTransforms(style) {\n  if (style.translate) {\n    style.removeProperty(\"translate\");\n    style.removeProperty(\"scale\");\n    style.removeProperty(\"rotate\");\n  }\n},\n    _revertStyle = function _revertStyle() {\n  var props = this.props,\n      target = this.target,\n      style = target.style,\n      cache = target._gsap,\n      i,\n      p;\n\n  for (i = 0; i < props.length; i += 3) {\n    // stored like this: property, isNotCSS, value\n    props[i + 1] ? target[props[i]] = props[i + 2] : props[i + 2] ? style[props[i]] = props[i + 2] : style.removeProperty(props[i].substr(0, 2) === \"--\" ? props[i] : props[i].replace(_capsExp, \"-$1\").toLowerCase());\n  }\n\n  if (this.tfm) {\n    for (p in this.tfm) {\n      cache[p] = this.tfm[p];\n    }\n\n    if (cache.svg) {\n      cache.renderTransform();\n      target.setAttribute(\"data-svg-origin\", this.svgo || \"\");\n    }\n\n    i = _reverting();\n\n    if ((!i || !i.isStart) && !style[_transformProp]) {\n      _removeIndependentTransforms(style);\n\n      if (cache.zOrigin && style[_transformOriginProp]) {\n        style[_transformOriginProp] += \" \" + cache.zOrigin + \"px\"; // since we're uncaching, we must put the zOrigin back into the transformOrigin so that we can pull it out accurately when we parse again. Otherwise, we'd lose the z portion of the origin since we extract it to protect from Safari bugs.\n\n        cache.zOrigin = 0;\n        cache.renderTransform();\n      }\n\n      cache.uncache = 1; // if it's a startAt that's being reverted in the _initTween() of the core, we don't need to uncache transforms. This is purely a performance optimization.\n    }\n  }\n},\n    _getStyleSaver = function _getStyleSaver(target, properties) {\n  var saver = {\n    target: target,\n    props: [],\n    revert: _revertStyle,\n    save: _saveStyle\n  };\n  target._gsap || gsap.core.getCache(target); // just make sure there's a _gsap cache defined because we read from it in _saveStyle() and it's more efficient to just check it here once.\n\n  properties && properties.split(\",\").forEach(function (p) {\n    return saver.save(p);\n  });\n  return saver;\n},\n    _supports3D,\n    _createElement = function _createElement(type, ns) {\n  var e = _doc.createElementNS ? _doc.createElementNS((ns || \"http://www.w3.org/1999/xhtml\").replace(/^https/, \"http\"), type) : _doc.createElement(type); //some servers swap in https for http in the namespace which can break things, making \"style\" inaccessible.\n\n  return e && e.style ? e : _doc.createElement(type); //some environments won't allow access to the element's style when created with a namespace in which case we default to the standard createElement() to work around the issue. Also note that when GSAP is embedded directly inside an SVG file, createElement() won't allow access to the style object in Firefox (see https://gsap.com/forums/topic/20215-problem-using-tweenmax-in-standalone-self-containing-svg-file-err-cannot-set-property-csstext-of-undefined/).\n},\n    _getComputedProperty = function _getComputedProperty(target, property, skipPrefixFallback) {\n  var cs = getComputedStyle(target);\n  return cs[property] || cs.getPropertyValue(property.replace(_capsExp, \"-$1\").toLowerCase()) || cs.getPropertyValue(property) || !skipPrefixFallback && _getComputedProperty(target, _checkPropPrefix(property) || property, 1) || \"\"; //css variables may not need caps swapped out for dashes and lowercase.\n},\n    _prefixes = \"O,Moz,ms,Ms,Webkit\".split(\",\"),\n    _checkPropPrefix = function _checkPropPrefix(property, element, preferPrefix) {\n  var e = element || _tempDiv,\n      s = e.style,\n      i = 5;\n\n  if (property in s && !preferPrefix) {\n    return property;\n  }\n\n  property = property.charAt(0).toUpperCase() + property.substr(1);\n\n  while (i-- && !(_prefixes[i] + property in s)) {}\n\n  return i < 0 ? null : (i === 3 ? \"ms\" : i >= 0 ? _prefixes[i] : \"\") + property;\n},\n    _initCore = function _initCore() {\n  if (_windowExists() && window.document) {\n    _win = window;\n    _doc = _win.document;\n    _docElement = _doc.documentElement;\n    _tempDiv = _createElement(\"div\") || {\n      style: {}\n    };\n    _tempDivStyler = _createElement(\"div\");\n    _transformProp = _checkPropPrefix(_transformProp);\n    _transformOriginProp = _transformProp + \"Origin\";\n    _tempDiv.style.cssText = \"border-width:0;line-height:0;position:absolute;padding:0\"; //make sure to override certain properties that may contaminate measurements, in case the user has overreaching style sheets.\n\n    _supports3D = !!_checkPropPrefix(\"perspective\");\n    _reverting = gsap.core.reverting;\n    _pluginInitted = 1;\n  }\n},\n    _getBBoxHack = function _getBBoxHack(swapIfPossible) {\n  //works around issues in some browsers (like Firefox) that don't correctly report getBBox() on SVG elements inside a <defs> element and/or <mask>. We try creating an SVG, adding it to the documentElement and toss the element in there so that it's definitely part of the rendering tree, then grab the bbox and if it works, we actually swap out the original getBBox() method for our own that does these extra steps whenever getBBox is needed. This helps ensure that performance is optimal (only do all these extra steps when absolutely necessary...most elements don't need it).\n  var svg = _createElement(\"svg\", this.ownerSVGElement && this.ownerSVGElement.getAttribute(\"xmlns\") || \"http://www.w3.org/2000/svg\"),\n      oldParent = this.parentNode,\n      oldSibling = this.nextSibling,\n      oldCSS = this.style.cssText,\n      bbox;\n\n  _docElement.appendChild(svg);\n\n  svg.appendChild(this);\n  this.style.display = \"block\";\n\n  if (swapIfPossible) {\n    try {\n      bbox = this.getBBox();\n      this._gsapBBox = this.getBBox; //store the original\n\n      this.getBBox = _getBBoxHack;\n    } catch (e) {}\n  } else if (this._gsapBBox) {\n    bbox = this._gsapBBox();\n  }\n\n  if (oldParent) {\n    if (oldSibling) {\n      oldParent.insertBefore(this, oldSibling);\n    } else {\n      oldParent.appendChild(this);\n    }\n  }\n\n  _docElement.removeChild(svg);\n\n  this.style.cssText = oldCSS;\n  return bbox;\n},\n    _getAttributeFallbacks = function _getAttributeFallbacks(target, attributesArray) {\n  var i = attributesArray.length;\n\n  while (i--) {\n    if (target.hasAttribute(attributesArray[i])) {\n      return target.getAttribute(attributesArray[i]);\n    }\n  }\n},\n    _getBBox = function _getBBox(target) {\n  var bounds;\n\n  try {\n    bounds = target.getBBox(); //Firefox throws errors if you try calling getBBox() on an SVG element that's not rendered (like in a <symbol> or <defs>). https://bugzilla.mozilla.org/show_bug.cgi?id=612118\n  } catch (error) {\n    bounds = _getBBoxHack.call(target, true);\n  }\n\n  bounds && (bounds.width || bounds.height) || target.getBBox === _getBBoxHack || (bounds = _getBBoxHack.call(target, true)); //some browsers (like Firefox) misreport the bounds if the element has zero width and height (it just assumes it's at x:0, y:0), thus we need to manually grab the position in that case.\n\n  return bounds && !bounds.width && !bounds.x && !bounds.y ? {\n    x: +_getAttributeFallbacks(target, [\"x\", \"cx\", \"x1\"]) || 0,\n    y: +_getAttributeFallbacks(target, [\"y\", \"cy\", \"y1\"]) || 0,\n    width: 0,\n    height: 0\n  } : bounds;\n},\n    _isSVG = function _isSVG(e) {\n  return !!(e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e));\n},\n    //reports if the element is an SVG on which getBBox() actually works\n_removeProperty = function _removeProperty(target, property) {\n  if (property) {\n    var style = target.style,\n        first2Chars;\n\n    if (property in _transformProps && property !== _transformOriginProp) {\n      property = _transformProp;\n    }\n\n    if (style.removeProperty) {\n      first2Chars = property.substr(0, 2);\n\n      if (first2Chars === \"ms\" || property.substr(0, 6) === \"webkit\") {\n        //Microsoft and some Webkit browsers don't conform to the standard of capitalizing the first prefix character, so we adjust so that when we prefix the caps with a dash, it's correct (otherwise it'd be \"ms-transform\" instead of \"-ms-transform\" for IE9, for example)\n        property = \"-\" + property;\n      }\n\n      style.removeProperty(first2Chars === \"--\" ? property : property.replace(_capsExp, \"-$1\").toLowerCase());\n    } else {\n      //note: old versions of IE use \"removeAttribute()\" instead of \"removeProperty()\"\n      style.removeAttribute(property);\n    }\n  }\n},\n    _addNonTweeningPT = function _addNonTweeningPT(plugin, target, property, beginning, end, onlySetAtEnd) {\n  var pt = new PropTween(plugin._pt, target, property, 0, 1, onlySetAtEnd ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue);\n  plugin._pt = pt;\n  pt.b = beginning;\n  pt.e = end;\n\n  plugin._props.push(property);\n\n  return pt;\n},\n    _nonConvertibleUnits = {\n  deg: 1,\n  rad: 1,\n  turn: 1\n},\n    _nonStandardLayouts = {\n  grid: 1,\n  flex: 1\n},\n    //takes a single value like 20px and converts it to the unit specified, like \"%\", returning only the numeric amount.\n_convertToUnit = function _convertToUnit(target, property, value, unit) {\n  var curValue = parseFloat(value) || 0,\n      curUnit = (value + \"\").trim().substr((curValue + \"\").length) || \"px\",\n      // some browsers leave extra whitespace at the beginning of CSS variables, hence the need to trim()\n  style = _tempDiv.style,\n      horizontal = _horizontalExp.test(property),\n      isRootSVG = target.tagName.toLowerCase() === \"svg\",\n      measureProperty = (isRootSVG ? \"client\" : \"offset\") + (horizontal ? \"Width\" : \"Height\"),\n      amount = 100,\n      toPixels = unit === \"px\",\n      toPercent = unit === \"%\",\n      px,\n      parent,\n      cache,\n      isSVG;\n\n  if (unit === curUnit || !curValue || _nonConvertibleUnits[unit] || _nonConvertibleUnits[curUnit]) {\n    return curValue;\n  }\n\n  curUnit !== \"px\" && !toPixels && (curValue = _convertToUnit(target, property, value, \"px\"));\n  isSVG = target.getCTM && _isSVG(target);\n\n  if ((toPercent || curUnit === \"%\") && (_transformProps[property] || ~property.indexOf(\"adius\"))) {\n    px = isSVG ? target.getBBox()[horizontal ? \"width\" : \"height\"] : target[measureProperty];\n    return _round(toPercent ? curValue / px * amount : curValue / 100 * px);\n  }\n\n  style[horizontal ? \"width\" : \"height\"] = amount + (toPixels ? curUnit : unit);\n  parent = ~property.indexOf(\"adius\") || unit === \"em\" && target.appendChild && !isRootSVG ? target : target.parentNode;\n\n  if (isSVG) {\n    parent = (target.ownerSVGElement || {}).parentNode;\n  }\n\n  if (!parent || parent === _doc || !parent.appendChild) {\n    parent = _doc.body;\n  }\n\n  cache = parent._gsap;\n\n  if (cache && toPercent && cache.width && horizontal && cache.time === _ticker.time && !cache.uncache) {\n    return _round(curValue / cache.width * amount);\n  } else {\n    if (toPercent && (property === \"height\" || property === \"width\")) {\n      // if we're dealing with width/height that's inside a container with padding and/or it's a flexbox/grid container, we must apply it to the target itself rather than the _tempDiv in order to ensure complete accuracy, factoring in the parent's padding.\n      var v = target.style[property];\n      target.style[property] = amount + unit;\n      px = target[measureProperty];\n      v ? target.style[property] = v : _removeProperty(target, property);\n    } else {\n      (toPercent || curUnit === \"%\") && !_nonStandardLayouts[_getComputedProperty(parent, \"display\")] && (style.position = _getComputedProperty(target, \"position\"));\n      parent === target && (style.position = \"static\"); // like for borderRadius, if it's a % we must have it relative to the target itself but that may not have position: relative or position: absolute in which case it'd go up the chain until it finds its offsetParent (bad). position: static protects against that.\n\n      parent.appendChild(_tempDiv);\n      px = _tempDiv[measureProperty];\n      parent.removeChild(_tempDiv);\n      style.position = \"absolute\";\n    }\n\n    if (horizontal && toPercent) {\n      cache = _getCache(parent);\n      cache.time = _ticker.time;\n      cache.width = parent[measureProperty];\n    }\n  }\n\n  return _round(toPixels ? px * curValue / amount : px && curValue ? amount / px * curValue : 0);\n},\n    _get = function _get(target, property, unit, uncache) {\n  var value;\n  _pluginInitted || _initCore();\n\n  if (property in _propertyAliases && property !== \"transform\") {\n    property = _propertyAliases[property];\n\n    if (~property.indexOf(\",\")) {\n      property = property.split(\",\")[0];\n    }\n  }\n\n  if (_transformProps[property] && property !== \"transform\") {\n    value = _parseTransform(target, uncache);\n    value = property !== \"transformOrigin\" ? value[property] : value.svg ? value.origin : _firstTwoOnly(_getComputedProperty(target, _transformOriginProp)) + \" \" + value.zOrigin + \"px\";\n  } else {\n    value = target.style[property];\n\n    if (!value || value === \"auto\" || uncache || ~(value + \"\").indexOf(\"calc(\")) {\n      value = _specialProps[property] && _specialProps[property](target, property, unit) || _getComputedProperty(target, property) || _getProperty(target, property) || (property === \"opacity\" ? 1 : 0); // note: some browsers, like Firefox, don't report borderRadius correctly! Instead, it only reports every corner like  borderTopLeftRadius\n    }\n  }\n\n  return unit && !~(value + \"\").trim().indexOf(\" \") ? _convertToUnit(target, property, value, unit) + unit : value;\n},\n    _tweenComplexCSSString = function _tweenComplexCSSString(target, prop, start, end) {\n  // note: we call _tweenComplexCSSString.call(pluginInstance...) to ensure that it's scoped properly. We may call it from within a plugin too, thus \"this\" would refer to the plugin.\n  if (!start || start === \"none\") {\n    // some browsers like Safari actually PREFER the prefixed property and mis-report the unprefixed value like clipPath (BUG). In other words, even though clipPath exists in the style (\"clipPath\" in target.style) and it's set in the CSS properly (along with -webkit-clip-path), Safari reports clipPath as \"none\" whereas WebkitClipPath reports accurately like \"ellipse(100% 0% at 50% 0%)\", so in this case we must SWITCH to using the prefixed property instead. See https://gsap.com/forums/topic/18310-clippath-doesnt-work-on-ios/\n    var p = _checkPropPrefix(prop, target, 1),\n        s = p && _getComputedProperty(target, p, 1);\n\n    if (s && s !== start) {\n      prop = p;\n      start = s;\n    } else if (prop === \"borderColor\") {\n      start = _getComputedProperty(target, \"borderTopColor\"); // Firefox bug: always reports \"borderColor\" as \"\", so we must fall back to borderTopColor. See https://gsap.com/forums/topic/24583-how-to-return-colors-that-i-had-after-reverse/\n    }\n  }\n\n  var pt = new PropTween(this._pt, target.style, prop, 0, 1, _renderComplexString),\n      index = 0,\n      matchIndex = 0,\n      a,\n      result,\n      startValues,\n      startNum,\n      color,\n      startValue,\n      endValue,\n      endNum,\n      chunk,\n      endUnit,\n      startUnit,\n      endValues;\n  pt.b = start;\n  pt.e = end;\n  start += \"\"; // ensure values are strings\n\n  end += \"\";\n\n  if (end === \"auto\") {\n    startValue = target.style[prop];\n    target.style[prop] = end;\n    end = _getComputedProperty(target, prop) || end;\n    startValue ? target.style[prop] = startValue : _removeProperty(target, prop);\n  }\n\n  a = [start, end];\n\n  _colorStringFilter(a); // pass an array with the starting and ending values and let the filter do whatever it needs to the values. If colors are found, it returns true and then we must match where the color shows up order-wise because for things like boxShadow, sometimes the browser provides the computed values with the color FIRST, but the user provides it with the color LAST, so flip them if necessary. Same for drop-shadow().\n\n\n  start = a[0];\n  end = a[1];\n  startValues = start.match(_numWithUnitExp) || [];\n  endValues = end.match(_numWithUnitExp) || [];\n\n  if (endValues.length) {\n    while (result = _numWithUnitExp.exec(end)) {\n      endValue = result[0];\n      chunk = end.substring(index, result.index);\n\n      if (color) {\n        color = (color + 1) % 5;\n      } else if (chunk.substr(-5) === \"rgba(\" || chunk.substr(-5) === \"hsla(\") {\n        color = 1;\n      }\n\n      if (endValue !== (startValue = startValues[matchIndex++] || \"\")) {\n        startNum = parseFloat(startValue) || 0;\n        startUnit = startValue.substr((startNum + \"\").length);\n        endValue.charAt(1) === \"=\" && (endValue = _parseRelative(startNum, endValue) + startUnit);\n        endNum = parseFloat(endValue);\n        endUnit = endValue.substr((endNum + \"\").length);\n        index = _numWithUnitExp.lastIndex - endUnit.length;\n\n        if (!endUnit) {\n          //if something like \"perspective:300\" is passed in and we must add a unit to the end\n          endUnit = endUnit || _config.units[prop] || startUnit;\n\n          if (index === end.length) {\n            end += endUnit;\n            pt.e += endUnit;\n          }\n        }\n\n        if (startUnit !== endUnit) {\n          startNum = _convertToUnit(target, prop, startValue, endUnit) || 0;\n        } // these nested PropTweens are handled in a special way - we'll never actually call a render or setter method on them. We'll just loop through them in the parent complex string PropTween's render method.\n\n\n        pt._pt = {\n          _next: pt._pt,\n          p: chunk || matchIndex === 1 ? chunk : \",\",\n          //note: SVG spec allows omission of comma/space when a negative sign is wedged between two numbers, like 2.5-5.3 instead of 2.5,-5.3 but when tweening, the negative value may switch to positive, so we insert the comma just in case.\n          s: startNum,\n          c: endNum - startNum,\n          m: color && color < 4 || prop === \"zIndex\" ? Math.round : 0\n        };\n      }\n    }\n\n    pt.c = index < end.length ? end.substring(index, end.length) : \"\"; //we use the \"c\" of the PropTween to store the final part of the string (after the last number)\n  } else {\n    pt.r = prop === \"display\" && end === \"none\" ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue;\n  }\n\n  _relExp.test(end) && (pt.e = 0); //if the end string contains relative values or dynamic random(...) values, delete the end it so that on the final render we don't actually set it to the string with += or -= characters (forces it to use the calculated value).\n\n  this._pt = pt; //start the linked list with this new PropTween. Remember, we call _tweenComplexCSSString.call(pluginInstance...) to ensure that it's scoped properly. We may call it from within another plugin too, thus \"this\" would refer to the plugin.\n\n  return pt;\n},\n    _keywordToPercent = {\n  top: \"0%\",\n  bottom: \"100%\",\n  left: \"0%\",\n  right: \"100%\",\n  center: \"50%\"\n},\n    _convertKeywordsToPercentages = function _convertKeywordsToPercentages(value) {\n  var split = value.split(\" \"),\n      x = split[0],\n      y = split[1] || \"50%\";\n\n  if (x === \"top\" || x === \"bottom\" || y === \"left\" || y === \"right\") {\n    //the user provided them in the wrong order, so flip them\n    value = x;\n    x = y;\n    y = value;\n  }\n\n  split[0] = _keywordToPercent[x] || x;\n  split[1] = _keywordToPercent[y] || y;\n  return split.join(\" \");\n},\n    _renderClearProps = function _renderClearProps(ratio, data) {\n  if (data.tween && data.tween._time === data.tween._dur) {\n    var target = data.t,\n        style = target.style,\n        props = data.u,\n        cache = target._gsap,\n        prop,\n        clearTransforms,\n        i;\n\n    if (props === \"all\" || props === true) {\n      style.cssText = \"\";\n      clearTransforms = 1;\n    } else {\n      props = props.split(\",\");\n      i = props.length;\n\n      while (--i > -1) {\n        prop = props[i];\n\n        if (_transformProps[prop]) {\n          clearTransforms = 1;\n          prop = prop === \"transformOrigin\" ? _transformOriginProp : _transformProp;\n        }\n\n        _removeProperty(target, prop);\n      }\n    }\n\n    if (clearTransforms) {\n      _removeProperty(target, _transformProp);\n\n      if (cache) {\n        cache.svg && target.removeAttribute(\"transform\");\n\n        _parseTransform(target, 1); // force all the cached values back to \"normal\"/identity, otherwise if there's another tween that's already set to render transforms on this element, it could display the wrong values.\n\n\n        cache.uncache = 1;\n\n        _removeIndependentTransforms(style);\n      }\n    }\n  }\n},\n    // note: specialProps should return 1 if (and only if) they have a non-zero priority. It indicates we need to sort the linked list.\n_specialProps = {\n  clearProps: function clearProps(plugin, target, property, endValue, tween) {\n    if (tween.data !== \"isFromStart\") {\n      var pt = plugin._pt = new PropTween(plugin._pt, target, property, 0, 0, _renderClearProps);\n      pt.u = endValue;\n      pt.pr = -10;\n      pt.tween = tween;\n\n      plugin._props.push(property);\n\n      return 1;\n    }\n  }\n  /* className feature (about 0.4kb gzipped).\n  , className(plugin, target, property, endValue, tween) {\n  \tlet _renderClassName = (ratio, data) => {\n  \t\t\tdata.css.render(ratio, data.css);\n  \t\t\tif (!ratio || ratio === 1) {\n  \t\t\t\tlet inline = data.rmv,\n  \t\t\t\t\ttarget = data.t,\n  \t\t\t\t\tp;\n  \t\t\t\ttarget.setAttribute(\"class\", ratio ? data.e : data.b);\n  \t\t\t\tfor (p in inline) {\n  \t\t\t\t\t_removeProperty(target, p);\n  \t\t\t\t}\n  \t\t\t}\n  \t\t},\n  \t\t_getAllStyles = (target) => {\n  \t\t\tlet styles = {},\n  \t\t\t\tcomputed = getComputedStyle(target),\n  \t\t\t\tp;\n  \t\t\tfor (p in computed) {\n  \t\t\t\tif (isNaN(p) && p !== \"cssText\" && p !== \"length\") {\n  \t\t\t\t\tstyles[p] = computed[p];\n  \t\t\t\t}\n  \t\t\t}\n  \t\t\t_setDefaults(styles, _parseTransform(target, 1));\n  \t\t\treturn styles;\n  \t\t},\n  \t\tstartClassList = target.getAttribute(\"class\"),\n  \t\tstyle = target.style,\n  \t\tcssText = style.cssText,\n  \t\tcache = target._gsap,\n  \t\tclassPT = cache.classPT,\n  \t\tinlineToRemoveAtEnd = {},\n  \t\tdata = {t:target, plugin:plugin, rmv:inlineToRemoveAtEnd, b:startClassList, e:(endValue.charAt(1) !== \"=\") ? endValue : startClassList.replace(new RegExp(\"(?:\\\\s|^)\" + endValue.substr(2) + \"(?![\\\\w-])\"), \"\") + ((endValue.charAt(0) === \"+\") ? \" \" + endValue.substr(2) : \"\")},\n  \t\tchangingVars = {},\n  \t\tstartVars = _getAllStyles(target),\n  \t\ttransformRelated = /(transform|perspective)/i,\n  \t\tendVars, p;\n  \tif (classPT) {\n  \t\tclassPT.r(1, classPT.d);\n  \t\t_removeLinkedListItem(classPT.d.plugin, classPT, \"_pt\");\n  \t}\n  \ttarget.setAttribute(\"class\", data.e);\n  \tendVars = _getAllStyles(target, true);\n  \ttarget.setAttribute(\"class\", startClassList);\n  \tfor (p in endVars) {\n  \t\tif (endVars[p] !== startVars[p] && !transformRelated.test(p)) {\n  \t\t\tchangingVars[p] = endVars[p];\n  \t\t\tif (!style[p] && style[p] !== \"0\") {\n  \t\t\t\tinlineToRemoveAtEnd[p] = 1;\n  \t\t\t}\n  \t\t}\n  \t}\n  \tcache.classPT = plugin._pt = new PropTween(plugin._pt, target, \"className\", 0, 0, _renderClassName, data, 0, -11);\n  \tif (style.cssText !== cssText) { //only apply if things change. Otherwise, in cases like a background-image that's pulled dynamically, it could cause a refresh. See https://gsap.com/forums/topic/20368-possible-gsap-bug-switching-classnames-in-chrome/.\n  \t\tstyle.cssText = cssText; //we recorded cssText before we swapped classes and ran _getAllStyles() because in cases when a className tween is overwritten, we remove all the related tweening properties from that class change (otherwise class-specific stuff can't override properties we've directly set on the target's style object due to specificity).\n  \t}\n  \t_parseTransform(target, true); //to clear the caching of transforms\n  \tdata.css = new gsap.plugins.css();\n  \tdata.css.init(target, changingVars, tween);\n  \tplugin._props.push(...data.css._props);\n  \treturn 1;\n  }\n  */\n\n},\n\n/*\n * --------------------------------------------------------------------------------------\n * TRANSFORMS\n * --------------------------------------------------------------------------------------\n */\n_identity2DMatrix = [1, 0, 0, 1, 0, 0],\n    _rotationalProperties = {},\n    _isNullTransform = function _isNullTransform(value) {\n  return value === \"matrix(1, 0, 0, 1, 0, 0)\" || value === \"none\" || !value;\n},\n    _getComputedTransformMatrixAsArray = function _getComputedTransformMatrixAsArray(target) {\n  var matrixString = _getComputedProperty(target, _transformProp);\n\n  return _isNullTransform(matrixString) ? _identity2DMatrix : matrixString.substr(7).match(_numExp).map(_round);\n},\n    _getMatrix = function _getMatrix(target, force2D) {\n  var cache = target._gsap || _getCache(target),\n      style = target.style,\n      matrix = _getComputedTransformMatrixAsArray(target),\n      parent,\n      nextSibling,\n      temp,\n      addedToDOM;\n\n  if (cache.svg && target.getAttribute(\"transform\")) {\n    temp = target.transform.baseVal.consolidate().matrix; //ensures that even complex values like \"translate(50,60) rotate(135,0,0)\" are parsed because it mashes it into a matrix.\n\n    matrix = [temp.a, temp.b, temp.c, temp.d, temp.e, temp.f];\n    return matrix.join(\",\") === \"1,0,0,1,0,0\" ? _identity2DMatrix : matrix;\n  } else if (matrix === _identity2DMatrix && !target.offsetParent && target !== _docElement && !cache.svg) {\n    //note: if offsetParent is null, that means the element isn't in the normal document flow, like if it has display:none or one of its ancestors has display:none). Firefox returns null for getComputedStyle() if the element is in an iframe that has display:none. https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n    //browsers don't report transforms accurately unless the element is in the DOM and has a display value that's not \"none\". Firefox and Microsoft browsers have a partial bug where they'll report transforms even if display:none BUT not any percentage-based values like translate(-50%, 8px) will be reported as if it's translate(0, 8px).\n    temp = style.display;\n    style.display = \"block\";\n    parent = target.parentNode;\n\n    if (!parent || !target.offsetParent) {\n      // note: in 3.3.0 we switched target.offsetParent to _doc.body.contains(target) to avoid [sometimes unnecessary] MutationObserver calls but that wasn't adequate because there are edge cases where nested position: fixed elements need to get reparented to accurately sense transforms. See https://github.com/greensock/GSAP/issues/388 and https://github.com/greensock/GSAP/issues/375\n      addedToDOM = 1; //flag\n\n      nextSibling = target.nextElementSibling;\n\n      _docElement.appendChild(target); //we must add it to the DOM in order to get values properly\n\n    }\n\n    matrix = _getComputedTransformMatrixAsArray(target);\n    temp ? style.display = temp : _removeProperty(target, \"display\");\n\n    if (addedToDOM) {\n      nextSibling ? parent.insertBefore(target, nextSibling) : parent ? parent.appendChild(target) : _docElement.removeChild(target);\n    }\n  }\n\n  return force2D && matrix.length > 6 ? [matrix[0], matrix[1], matrix[4], matrix[5], matrix[12], matrix[13]] : matrix;\n},\n    _applySVGOrigin = function _applySVGOrigin(target, origin, originIsAbsolute, smooth, matrixArray, pluginToAddPropTweensTo) {\n  var cache = target._gsap,\n      matrix = matrixArray || _getMatrix(target, true),\n      xOriginOld = cache.xOrigin || 0,\n      yOriginOld = cache.yOrigin || 0,\n      xOffsetOld = cache.xOffset || 0,\n      yOffsetOld = cache.yOffset || 0,\n      a = matrix[0],\n      b = matrix[1],\n      c = matrix[2],\n      d = matrix[3],\n      tx = matrix[4],\n      ty = matrix[5],\n      originSplit = origin.split(\" \"),\n      xOrigin = parseFloat(originSplit[0]) || 0,\n      yOrigin = parseFloat(originSplit[1]) || 0,\n      bounds,\n      determinant,\n      x,\n      y;\n\n  if (!originIsAbsolute) {\n    bounds = _getBBox(target);\n    xOrigin = bounds.x + (~originSplit[0].indexOf(\"%\") ? xOrigin / 100 * bounds.width : xOrigin);\n    yOrigin = bounds.y + (~(originSplit[1] || originSplit[0]).indexOf(\"%\") ? yOrigin / 100 * bounds.height : yOrigin); // if (!(\"xOrigin\" in cache) && (xOrigin || yOrigin)) { // added in 3.12.3, reverted in 3.12.4; requires more exploration\n    // \txOrigin -= bounds.x;\n    // \tyOrigin -= bounds.y;\n    // }\n  } else if (matrix !== _identity2DMatrix && (determinant = a * d - b * c)) {\n    //if it's zero (like if scaleX and scaleY are zero), skip it to avoid errors with dividing by zero.\n    x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + (c * ty - d * tx) / determinant;\n    y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - (a * ty - b * tx) / determinant;\n    xOrigin = x;\n    yOrigin = y; // theory: we only had to do this for smoothing and it assumes that the previous one was not originIsAbsolute.\n  }\n\n  if (smooth || smooth !== false && cache.smooth) {\n    tx = xOrigin - xOriginOld;\n    ty = yOrigin - yOriginOld;\n    cache.xOffset = xOffsetOld + (tx * a + ty * c) - tx;\n    cache.yOffset = yOffsetOld + (tx * b + ty * d) - ty;\n  } else {\n    cache.xOffset = cache.yOffset = 0;\n  }\n\n  cache.xOrigin = xOrigin;\n  cache.yOrigin = yOrigin;\n  cache.smooth = !!smooth;\n  cache.origin = origin;\n  cache.originIsAbsolute = !!originIsAbsolute;\n  target.style[_transformOriginProp] = \"0px 0px\"; //otherwise, if someone sets  an origin via CSS, it will likely interfere with the SVG transform attribute ones (because remember, we're baking the origin into the matrix() value).\n\n  if (pluginToAddPropTweensTo) {\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"xOrigin\", xOriginOld, xOrigin);\n\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"yOrigin\", yOriginOld, yOrigin);\n\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"xOffset\", xOffsetOld, cache.xOffset);\n\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"yOffset\", yOffsetOld, cache.yOffset);\n  }\n\n  target.setAttribute(\"data-svg-origin\", xOrigin + \" \" + yOrigin);\n},\n    _parseTransform = function _parseTransform(target, uncache) {\n  var cache = target._gsap || new GSCache(target);\n\n  if (\"x\" in cache && !uncache && !cache.uncache) {\n    return cache;\n  }\n\n  var style = target.style,\n      invertedScaleX = cache.scaleX < 0,\n      px = \"px\",\n      deg = \"deg\",\n      cs = getComputedStyle(target),\n      origin = _getComputedProperty(target, _transformOriginProp) || \"0\",\n      x,\n      y,\n      z,\n      scaleX,\n      scaleY,\n      rotation,\n      rotationX,\n      rotationY,\n      skewX,\n      skewY,\n      perspective,\n      xOrigin,\n      yOrigin,\n      matrix,\n      angle,\n      cos,\n      sin,\n      a,\n      b,\n      c,\n      d,\n      a12,\n      a22,\n      t1,\n      t2,\n      t3,\n      a13,\n      a23,\n      a33,\n      a42,\n      a43,\n      a32;\n  x = y = z = rotation = rotationX = rotationY = skewX = skewY = perspective = 0;\n  scaleX = scaleY = 1;\n  cache.svg = !!(target.getCTM && _isSVG(target));\n\n  if (cs.translate) {\n    // accommodate independent transforms by combining them into normal ones.\n    if (cs.translate !== \"none\" || cs.scale !== \"none\" || cs.rotate !== \"none\") {\n      style[_transformProp] = (cs.translate !== \"none\" ? \"translate3d(\" + (cs.translate + \" 0 0\").split(\" \").slice(0, 3).join(\", \") + \") \" : \"\") + (cs.rotate !== \"none\" ? \"rotate(\" + cs.rotate + \") \" : \"\") + (cs.scale !== \"none\" ? \"scale(\" + cs.scale.split(\" \").join(\",\") + \") \" : \"\") + (cs[_transformProp] !== \"none\" ? cs[_transformProp] : \"\");\n    }\n\n    style.scale = style.rotate = style.translate = \"none\";\n  }\n\n  matrix = _getMatrix(target, cache.svg);\n\n  if (cache.svg) {\n    if (cache.uncache) {\n      // if cache.uncache is true (and maybe if origin is 0,0), we need to set element.style.transformOrigin = (cache.xOrigin - bbox.x) + \"px \" + (cache.yOrigin - bbox.y) + \"px\". Previously we let the data-svg-origin stay instead, but when introducing revert(), it complicated things.\n      t2 = target.getBBox();\n      origin = cache.xOrigin - t2.x + \"px \" + (cache.yOrigin - t2.y) + \"px\";\n      t1 = \"\";\n    } else {\n      t1 = !uncache && target.getAttribute(\"data-svg-origin\"); //  Remember, to work around browser inconsistencies we always force SVG elements' transformOrigin to 0,0 and offset the translation accordingly.\n    }\n\n    _applySVGOrigin(target, t1 || origin, !!t1 || cache.originIsAbsolute, cache.smooth !== false, matrix);\n  }\n\n  xOrigin = cache.xOrigin || 0;\n  yOrigin = cache.yOrigin || 0;\n\n  if (matrix !== _identity2DMatrix) {\n    a = matrix[0]; //a11\n\n    b = matrix[1]; //a21\n\n    c = matrix[2]; //a31\n\n    d = matrix[3]; //a41\n\n    x = a12 = matrix[4];\n    y = a22 = matrix[5]; //2D matrix\n\n    if (matrix.length === 6) {\n      scaleX = Math.sqrt(a * a + b * b);\n      scaleY = Math.sqrt(d * d + c * c);\n      rotation = a || b ? _atan2(b, a) * _RAD2DEG : 0; //note: if scaleX is 0, we cannot accurately measure rotation. Same for skewX with a scaleY of 0. Therefore, we default to the previously recorded value (or zero if that doesn't exist).\n\n      skewX = c || d ? _atan2(c, d) * _RAD2DEG + rotation : 0;\n      skewX && (scaleY *= Math.abs(Math.cos(skewX * _DEG2RAD)));\n\n      if (cache.svg) {\n        x -= xOrigin - (xOrigin * a + yOrigin * c);\n        y -= yOrigin - (xOrigin * b + yOrigin * d);\n      } //3D matrix\n\n    } else {\n      a32 = matrix[6];\n      a42 = matrix[7];\n      a13 = matrix[8];\n      a23 = matrix[9];\n      a33 = matrix[10];\n      a43 = matrix[11];\n      x = matrix[12];\n      y = matrix[13];\n      z = matrix[14];\n      angle = _atan2(a32, a33);\n      rotationX = angle * _RAD2DEG; //rotationX\n\n      if (angle) {\n        cos = Math.cos(-angle);\n        sin = Math.sin(-angle);\n        t1 = a12 * cos + a13 * sin;\n        t2 = a22 * cos + a23 * sin;\n        t3 = a32 * cos + a33 * sin;\n        a13 = a12 * -sin + a13 * cos;\n        a23 = a22 * -sin + a23 * cos;\n        a33 = a32 * -sin + a33 * cos;\n        a43 = a42 * -sin + a43 * cos;\n        a12 = t1;\n        a22 = t2;\n        a32 = t3;\n      } //rotationY\n\n\n      angle = _atan2(-c, a33);\n      rotationY = angle * _RAD2DEG;\n\n      if (angle) {\n        cos = Math.cos(-angle);\n        sin = Math.sin(-angle);\n        t1 = a * cos - a13 * sin;\n        t2 = b * cos - a23 * sin;\n        t3 = c * cos - a33 * sin;\n        a43 = d * sin + a43 * cos;\n        a = t1;\n        b = t2;\n        c = t3;\n      } //rotationZ\n\n\n      angle = _atan2(b, a);\n      rotation = angle * _RAD2DEG;\n\n      if (angle) {\n        cos = Math.cos(angle);\n        sin = Math.sin(angle);\n        t1 = a * cos + b * sin;\n        t2 = a12 * cos + a22 * sin;\n        b = b * cos - a * sin;\n        a22 = a22 * cos - a12 * sin;\n        a = t1;\n        a12 = t2;\n      }\n\n      if (rotationX && Math.abs(rotationX) + Math.abs(rotation) > 359.9) {\n        //when rotationY is set, it will often be parsed as 180 degrees different than it should be, and rotationX and rotation both being 180 (it looks the same), so we adjust for that here.\n        rotationX = rotation = 0;\n        rotationY = 180 - rotationY;\n      }\n\n      scaleX = _round(Math.sqrt(a * a + b * b + c * c));\n      scaleY = _round(Math.sqrt(a22 * a22 + a32 * a32));\n      angle = _atan2(a12, a22);\n      skewX = Math.abs(angle) > 0.0002 ? angle * _RAD2DEG : 0;\n      perspective = a43 ? 1 / (a43 < 0 ? -a43 : a43) : 0;\n    }\n\n    if (cache.svg) {\n      //sense if there are CSS transforms applied on an SVG element in which case we must overwrite them when rendering. The transform attribute is more reliable cross-browser, but we can't just remove the CSS ones because they may be applied in a CSS rule somewhere (not just inline).\n      t1 = target.getAttribute(\"transform\");\n      cache.forceCSS = target.setAttribute(\"transform\", \"\") || !_isNullTransform(_getComputedProperty(target, _transformProp));\n      t1 && target.setAttribute(\"transform\", t1);\n    }\n  }\n\n  if (Math.abs(skewX) > 90 && Math.abs(skewX) < 270) {\n    if (invertedScaleX) {\n      scaleX *= -1;\n      skewX += rotation <= 0 ? 180 : -180;\n      rotation += rotation <= 0 ? 180 : -180;\n    } else {\n      scaleY *= -1;\n      skewX += skewX <= 0 ? 180 : -180;\n    }\n  }\n\n  uncache = uncache || cache.uncache;\n  cache.x = x - ((cache.xPercent = x && (!uncache && cache.xPercent || (Math.round(target.offsetWidth / 2) === Math.round(-x) ? -50 : 0))) ? target.offsetWidth * cache.xPercent / 100 : 0) + px;\n  cache.y = y - ((cache.yPercent = y && (!uncache && cache.yPercent || (Math.round(target.offsetHeight / 2) === Math.round(-y) ? -50 : 0))) ? target.offsetHeight * cache.yPercent / 100 : 0) + px;\n  cache.z = z + px;\n  cache.scaleX = _round(scaleX);\n  cache.scaleY = _round(scaleY);\n  cache.rotation = _round(rotation) + deg;\n  cache.rotationX = _round(rotationX) + deg;\n  cache.rotationY = _round(rotationY) + deg;\n  cache.skewX = skewX + deg;\n  cache.skewY = skewY + deg;\n  cache.transformPerspective = perspective + px;\n\n  if (cache.zOrigin = parseFloat(origin.split(\" \")[2]) || !uncache && cache.zOrigin || 0) {\n    style[_transformOriginProp] = _firstTwoOnly(origin);\n  }\n\n  cache.xOffset = cache.yOffset = 0;\n  cache.force3D = _config.force3D;\n  cache.renderTransform = cache.svg ? _renderSVGTransforms : _supports3D ? _renderCSSTransforms : _renderNon3DTransforms;\n  cache.uncache = 0;\n  return cache;\n},\n    _firstTwoOnly = function _firstTwoOnly(value) {\n  return (value = value.split(\" \"))[0] + \" \" + value[1];\n},\n    //for handling transformOrigin values, stripping out the 3rd dimension\n_addPxTranslate = function _addPxTranslate(target, start, value) {\n  var unit = getUnit(start);\n  return _round(parseFloat(start) + parseFloat(_convertToUnit(target, \"x\", value + \"px\", unit))) + unit;\n},\n    _renderNon3DTransforms = function _renderNon3DTransforms(ratio, cache) {\n  cache.z = \"0px\";\n  cache.rotationY = cache.rotationX = \"0deg\";\n  cache.force3D = 0;\n\n  _renderCSSTransforms(ratio, cache);\n},\n    _zeroDeg = \"0deg\",\n    _zeroPx = \"0px\",\n    _endParenthesis = \") \",\n    _renderCSSTransforms = function _renderCSSTransforms(ratio, cache) {\n  var _ref = cache || this,\n      xPercent = _ref.xPercent,\n      yPercent = _ref.yPercent,\n      x = _ref.x,\n      y = _ref.y,\n      z = _ref.z,\n      rotation = _ref.rotation,\n      rotationY = _ref.rotationY,\n      rotationX = _ref.rotationX,\n      skewX = _ref.skewX,\n      skewY = _ref.skewY,\n      scaleX = _ref.scaleX,\n      scaleY = _ref.scaleY,\n      transformPerspective = _ref.transformPerspective,\n      force3D = _ref.force3D,\n      target = _ref.target,\n      zOrigin = _ref.zOrigin,\n      transforms = \"\",\n      use3D = force3D === \"auto\" && ratio && ratio !== 1 || force3D === true; // Safari has a bug that causes it not to render 3D transform-origin values properly, so we force the z origin to 0, record it in the cache, and then do the math here to offset the translate values accordingly (basically do the 3D transform-origin part manually)\n\n\n  if (zOrigin && (rotationX !== _zeroDeg || rotationY !== _zeroDeg)) {\n    var angle = parseFloat(rotationY) * _DEG2RAD,\n        a13 = Math.sin(angle),\n        a33 = Math.cos(angle),\n        cos;\n\n    angle = parseFloat(rotationX) * _DEG2RAD;\n    cos = Math.cos(angle);\n    x = _addPxTranslate(target, x, a13 * cos * -zOrigin);\n    y = _addPxTranslate(target, y, -Math.sin(angle) * -zOrigin);\n    z = _addPxTranslate(target, z, a33 * cos * -zOrigin + zOrigin);\n  }\n\n  if (transformPerspective !== _zeroPx) {\n    transforms += \"perspective(\" + transformPerspective + _endParenthesis;\n  }\n\n  if (xPercent || yPercent) {\n    transforms += \"translate(\" + xPercent + \"%, \" + yPercent + \"%) \";\n  }\n\n  if (use3D || x !== _zeroPx || y !== _zeroPx || z !== _zeroPx) {\n    transforms += z !== _zeroPx || use3D ? \"translate3d(\" + x + \", \" + y + \", \" + z + \") \" : \"translate(\" + x + \", \" + y + _endParenthesis;\n  }\n\n  if (rotation !== _zeroDeg) {\n    transforms += \"rotate(\" + rotation + _endParenthesis;\n  }\n\n  if (rotationY !== _zeroDeg) {\n    transforms += \"rotateY(\" + rotationY + _endParenthesis;\n  }\n\n  if (rotationX !== _zeroDeg) {\n    transforms += \"rotateX(\" + rotationX + _endParenthesis;\n  }\n\n  if (skewX !== _zeroDeg || skewY !== _zeroDeg) {\n    transforms += \"skew(\" + skewX + \", \" + skewY + _endParenthesis;\n  }\n\n  if (scaleX !== 1 || scaleY !== 1) {\n    transforms += \"scale(\" + scaleX + \", \" + scaleY + _endParenthesis;\n  }\n\n  target.style[_transformProp] = transforms || \"translate(0, 0)\";\n},\n    _renderSVGTransforms = function _renderSVGTransforms(ratio, cache) {\n  var _ref2 = cache || this,\n      xPercent = _ref2.xPercent,\n      yPercent = _ref2.yPercent,\n      x = _ref2.x,\n      y = _ref2.y,\n      rotation = _ref2.rotation,\n      skewX = _ref2.skewX,\n      skewY = _ref2.skewY,\n      scaleX = _ref2.scaleX,\n      scaleY = _ref2.scaleY,\n      target = _ref2.target,\n      xOrigin = _ref2.xOrigin,\n      yOrigin = _ref2.yOrigin,\n      xOffset = _ref2.xOffset,\n      yOffset = _ref2.yOffset,\n      forceCSS = _ref2.forceCSS,\n      tx = parseFloat(x),\n      ty = parseFloat(y),\n      a11,\n      a21,\n      a12,\n      a22,\n      temp;\n\n  rotation = parseFloat(rotation);\n  skewX = parseFloat(skewX);\n  skewY = parseFloat(skewY);\n\n  if (skewY) {\n    //for performance reasons, we combine all skewing into the skewX and rotation values. Remember, a skewY of 10 degrees looks the same as a rotation of 10 degrees plus a skewX of 10 degrees.\n    skewY = parseFloat(skewY);\n    skewX += skewY;\n    rotation += skewY;\n  }\n\n  if (rotation || skewX) {\n    rotation *= _DEG2RAD;\n    skewX *= _DEG2RAD;\n    a11 = Math.cos(rotation) * scaleX;\n    a21 = Math.sin(rotation) * scaleX;\n    a12 = Math.sin(rotation - skewX) * -scaleY;\n    a22 = Math.cos(rotation - skewX) * scaleY;\n\n    if (skewX) {\n      skewY *= _DEG2RAD;\n      temp = Math.tan(skewX - skewY);\n      temp = Math.sqrt(1 + temp * temp);\n      a12 *= temp;\n      a22 *= temp;\n\n      if (skewY) {\n        temp = Math.tan(skewY);\n        temp = Math.sqrt(1 + temp * temp);\n        a11 *= temp;\n        a21 *= temp;\n      }\n    }\n\n    a11 = _round(a11);\n    a21 = _round(a21);\n    a12 = _round(a12);\n    a22 = _round(a22);\n  } else {\n    a11 = scaleX;\n    a22 = scaleY;\n    a21 = a12 = 0;\n  }\n\n  if (tx && !~(x + \"\").indexOf(\"px\") || ty && !~(y + \"\").indexOf(\"px\")) {\n    tx = _convertToUnit(target, \"x\", x, \"px\");\n    ty = _convertToUnit(target, \"y\", y, \"px\");\n  }\n\n  if (xOrigin || yOrigin || xOffset || yOffset) {\n    tx = _round(tx + xOrigin - (xOrigin * a11 + yOrigin * a12) + xOffset);\n    ty = _round(ty + yOrigin - (xOrigin * a21 + yOrigin * a22) + yOffset);\n  }\n\n  if (xPercent || yPercent) {\n    //The SVG spec doesn't support percentage-based translation in the \"transform\" attribute, so we merge it into the translation to simulate it.\n    temp = target.getBBox();\n    tx = _round(tx + xPercent / 100 * temp.width);\n    ty = _round(ty + yPercent / 100 * temp.height);\n  }\n\n  temp = \"matrix(\" + a11 + \",\" + a21 + \",\" + a12 + \",\" + a22 + \",\" + tx + \",\" + ty + \")\";\n  target.setAttribute(\"transform\", temp);\n  forceCSS && (target.style[_transformProp] = temp); //some browsers prioritize CSS transforms over the transform attribute. When we sense that the user has CSS transforms applied, we must overwrite them this way (otherwise some browser simply won't render the transform attribute changes!)\n},\n    _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue) {\n  var cap = 360,\n      isString = _isString(endValue),\n      endNum = parseFloat(endValue) * (isString && ~endValue.indexOf(\"rad\") ? _RAD2DEG : 1),\n      change = endNum - startNum,\n      finalValue = startNum + change + \"deg\",\n      direction,\n      pt;\n\n  if (isString) {\n    direction = endValue.split(\"_\")[1];\n\n    if (direction === \"short\") {\n      change %= cap;\n\n      if (change !== change % (cap / 2)) {\n        change += change < 0 ? cap : -cap;\n      }\n    }\n\n    if (direction === \"cw\" && change < 0) {\n      change = (change + cap * _bigNum) % cap - ~~(change / cap) * cap;\n    } else if (direction === \"ccw\" && change > 0) {\n      change = (change - cap * _bigNum) % cap - ~~(change / cap) * cap;\n    }\n  }\n\n  plugin._pt = pt = new PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);\n  pt.e = finalValue;\n  pt.u = \"deg\";\n\n  plugin._props.push(property);\n\n  return pt;\n},\n    _assign = function _assign(target, source) {\n  // Internet Explorer doesn't have Object.assign(), so we recreate it here.\n  for (var p in source) {\n    target[p] = source[p];\n  }\n\n  return target;\n},\n    _addRawTransformPTs = function _addRawTransformPTs(plugin, transforms, target) {\n  //for handling cases where someone passes in a whole transform string, like transform: \"scale(2, 3) rotate(20deg) translateY(30em)\"\n  var startCache = _assign({}, target._gsap),\n      exclude = \"perspective,force3D,transformOrigin,svgOrigin\",\n      style = target.style,\n      endCache,\n      p,\n      startValue,\n      endValue,\n      startNum,\n      endNum,\n      startUnit,\n      endUnit;\n\n  if (startCache.svg) {\n    startValue = target.getAttribute(\"transform\");\n    target.setAttribute(\"transform\", \"\");\n    style[_transformProp] = transforms;\n    endCache = _parseTransform(target, 1);\n\n    _removeProperty(target, _transformProp);\n\n    target.setAttribute(\"transform\", startValue);\n  } else {\n    startValue = getComputedStyle(target)[_transformProp];\n    style[_transformProp] = transforms;\n    endCache = _parseTransform(target, 1);\n    style[_transformProp] = startValue;\n  }\n\n  for (p in _transformProps) {\n    startValue = startCache[p];\n    endValue = endCache[p];\n\n    if (startValue !== endValue && exclude.indexOf(p) < 0) {\n      //tweening to no perspective gives very unintuitive results - just keep the same perspective in that case.\n      startUnit = getUnit(startValue);\n      endUnit = getUnit(endValue);\n      startNum = startUnit !== endUnit ? _convertToUnit(target, p, startValue, endUnit) : parseFloat(startValue);\n      endNum = parseFloat(endValue);\n      plugin._pt = new PropTween(plugin._pt, endCache, p, startNum, endNum - startNum, _renderCSSProp);\n      plugin._pt.u = endUnit || 0;\n\n      plugin._props.push(p);\n    }\n  }\n\n  _assign(endCache, startCache);\n}; // handle splitting apart padding, margin, borderWidth, and borderRadius into their 4 components. Firefox, for example, won't report borderRadius correctly - it will only do borderTopLeftRadius and the other corners. We also want to handle paddingTop, marginLeft, borderRightWidth, etc.\n\n\n_forEachName(\"padding,margin,Width,Radius\", function (name, index) {\n  var t = \"Top\",\n      r = \"Right\",\n      b = \"Bottom\",\n      l = \"Left\",\n      props = (index < 3 ? [t, r, b, l] : [t + l, t + r, b + r, b + l]).map(function (side) {\n    return index < 2 ? name + side : \"border\" + side + name;\n  });\n\n  _specialProps[index > 1 ? \"border\" + name : name] = function (plugin, target, property, endValue, tween) {\n    var a, vars;\n\n    if (arguments.length < 4) {\n      // getter, passed target, property, and unit (from _get())\n      a = props.map(function (prop) {\n        return _get(plugin, prop, property);\n      });\n      vars = a.join(\" \");\n      return vars.split(a[0]).length === 5 ? a[0] : vars;\n    }\n\n    a = (endValue + \"\").split(\" \");\n    vars = {};\n    props.forEach(function (prop, i) {\n      return vars[prop] = a[i] = a[i] || a[(i - 1) / 2 | 0];\n    });\n    plugin.init(target, vars, tween);\n  };\n});\n\nexport var CSSPlugin = {\n  name: \"css\",\n  register: _initCore,\n  targetTest: function targetTest(target) {\n    return target.style && target.nodeType;\n  },\n  init: function init(target, vars, tween, index, targets) {\n    var props = this._props,\n        style = target.style,\n        startAt = tween.vars.startAt,\n        startValue,\n        endValue,\n        endNum,\n        startNum,\n        type,\n        specialProp,\n        p,\n        startUnit,\n        endUnit,\n        relative,\n        isTransformRelated,\n        transformPropTween,\n        cache,\n        smooth,\n        hasPriority,\n        inlineProps;\n    _pluginInitted || _initCore(); // we may call init() multiple times on the same plugin instance, like when adding special properties, so make sure we don't overwrite the revert data or inlineProps\n\n    this.styles = this.styles || _getStyleSaver(target);\n    inlineProps = this.styles.props;\n    this.tween = tween;\n\n    for (p in vars) {\n      if (p === \"autoRound\") {\n        continue;\n      }\n\n      endValue = vars[p];\n\n      if (_plugins[p] && _checkPlugin(p, vars, tween, index, target, targets)) {\n        // plugins\n        continue;\n      }\n\n      type = typeof endValue;\n      specialProp = _specialProps[p];\n\n      if (type === \"function\") {\n        endValue = endValue.call(tween, index, target, targets);\n        type = typeof endValue;\n      }\n\n      if (type === \"string\" && ~endValue.indexOf(\"random(\")) {\n        endValue = _replaceRandom(endValue);\n      }\n\n      if (specialProp) {\n        specialProp(this, target, p, endValue, tween) && (hasPriority = 1);\n      } else if (p.substr(0, 2) === \"--\") {\n        //CSS variable\n        startValue = (getComputedStyle(target).getPropertyValue(p) + \"\").trim();\n        endValue += \"\";\n        _colorExp.lastIndex = 0;\n\n        if (!_colorExp.test(startValue)) {\n          // colors don't have units\n          startUnit = getUnit(startValue);\n          endUnit = getUnit(endValue);\n        }\n\n        endUnit ? startUnit !== endUnit && (startValue = _convertToUnit(target, p, startValue, endUnit) + endUnit) : startUnit && (endValue += startUnit);\n        this.add(style, \"setProperty\", startValue, endValue, index, targets, 0, 0, p);\n        props.push(p);\n        inlineProps.push(p, 0, style[p]);\n      } else if (type !== \"undefined\") {\n        if (startAt && p in startAt) {\n          // in case someone hard-codes a complex value as the start, like top: \"calc(2vh / 2)\". Without this, it'd use the computed value (always in px)\n          startValue = typeof startAt[p] === \"function\" ? startAt[p].call(tween, index, target, targets) : startAt[p];\n          _isString(startValue) && ~startValue.indexOf(\"random(\") && (startValue = _replaceRandom(startValue));\n          getUnit(startValue + \"\") || startValue === \"auto\" || (startValue += _config.units[p] || getUnit(_get(target, p)) || \"\"); // for cases when someone passes in a unitless value like {x: 100}; if we try setting translate(100, 0px) it won't work.\n\n          (startValue + \"\").charAt(1) === \"=\" && (startValue = _get(target, p)); // can't work with relative values\n        } else {\n          startValue = _get(target, p);\n        }\n\n        startNum = parseFloat(startValue);\n        relative = type === \"string\" && endValue.charAt(1) === \"=\" && endValue.substr(0, 2);\n        relative && (endValue = endValue.substr(2));\n        endNum = parseFloat(endValue);\n\n        if (p in _propertyAliases) {\n          if (p === \"autoAlpha\") {\n            //special case where we control the visibility along with opacity. We still allow the opacity value to pass through and get tweened.\n            if (startNum === 1 && _get(target, \"visibility\") === \"hidden\" && endNum) {\n              //if visibility is initially set to \"hidden\", we should interpret that as intent to make opacity 0 (a convenience)\n              startNum = 0;\n            }\n\n            inlineProps.push(\"visibility\", 0, style.visibility);\n\n            _addNonTweeningPT(this, style, \"visibility\", startNum ? \"inherit\" : \"hidden\", endNum ? \"inherit\" : \"hidden\", !endNum);\n          }\n\n          if (p !== \"scale\" && p !== \"transform\") {\n            p = _propertyAliases[p];\n            ~p.indexOf(\",\") && (p = p.split(\",\")[0]);\n          }\n        }\n\n        isTransformRelated = p in _transformProps; //--- TRANSFORM-RELATED ---\n\n        if (isTransformRelated) {\n          this.styles.save(p);\n\n          if (!transformPropTween) {\n            cache = target._gsap;\n            cache.renderTransform && !vars.parseTransform || _parseTransform(target, vars.parseTransform); // if, for example, gsap.set(... {transform:\"translateX(50vw)\"}), the _get() call doesn't parse the transform, thus cache.renderTransform won't be set yet so force the parsing of the transform here.\n\n            smooth = vars.smoothOrigin !== false && cache.smooth;\n            transformPropTween = this._pt = new PropTween(this._pt, style, _transformProp, 0, 1, cache.renderTransform, cache, 0, -1); //the first time through, create the rendering PropTween so that it runs LAST (in the linked list, we keep adding to the beginning)\n\n            transformPropTween.dep = 1; //flag it as dependent so that if things get killed/overwritten and this is the only PropTween left, we can safely kill the whole tween.\n          }\n\n          if (p === \"scale\") {\n            this._pt = new PropTween(this._pt, cache, \"scaleY\", cache.scaleY, (relative ? _parseRelative(cache.scaleY, relative + endNum) : endNum) - cache.scaleY || 0, _renderCSSProp);\n            this._pt.u = 0;\n            props.push(\"scaleY\", p);\n            p += \"X\";\n          } else if (p === \"transformOrigin\") {\n            inlineProps.push(_transformOriginProp, 0, style[_transformOriginProp]);\n            endValue = _convertKeywordsToPercentages(endValue); //in case something like \"left top\" or \"bottom right\" is passed in. Convert to percentages.\n\n            if (cache.svg) {\n              _applySVGOrigin(target, endValue, 0, smooth, 0, this);\n            } else {\n              endUnit = parseFloat(endValue.split(\" \")[2]) || 0; //handle the zOrigin separately!\n\n              endUnit !== cache.zOrigin && _addNonTweeningPT(this, cache, \"zOrigin\", cache.zOrigin, endUnit);\n\n              _addNonTweeningPT(this, style, p, _firstTwoOnly(startValue), _firstTwoOnly(endValue));\n            }\n\n            continue;\n          } else if (p === \"svgOrigin\") {\n            _applySVGOrigin(target, endValue, 1, smooth, 0, this);\n\n            continue;\n          } else if (p in _rotationalProperties) {\n            _addRotationalPropTween(this, cache, p, startNum, relative ? _parseRelative(startNum, relative + endValue) : endValue);\n\n            continue;\n          } else if (p === \"smoothOrigin\") {\n            _addNonTweeningPT(this, cache, \"smooth\", cache.smooth, endValue);\n\n            continue;\n          } else if (p === \"force3D\") {\n            cache[p] = endValue;\n            continue;\n          } else if (p === \"transform\") {\n            _addRawTransformPTs(this, endValue, target);\n\n            continue;\n          }\n        } else if (!(p in style)) {\n          p = _checkPropPrefix(p) || p;\n        }\n\n        if (isTransformRelated || (endNum || endNum === 0) && (startNum || startNum === 0) && !_complexExp.test(endValue) && p in style) {\n          startUnit = (startValue + \"\").substr((startNum + \"\").length);\n          endNum || (endNum = 0); // protect against NaN\n\n          endUnit = getUnit(endValue) || (p in _config.units ? _config.units[p] : startUnit);\n          startUnit !== endUnit && (startNum = _convertToUnit(target, p, startValue, endUnit));\n          this._pt = new PropTween(this._pt, isTransformRelated ? cache : style, p, startNum, (relative ? _parseRelative(startNum, relative + endNum) : endNum) - startNum, !isTransformRelated && (endUnit === \"px\" || p === \"zIndex\") && vars.autoRound !== false ? _renderRoundedCSSProp : _renderCSSProp);\n          this._pt.u = endUnit || 0;\n\n          if (startUnit !== endUnit && endUnit !== \"%\") {\n            //when the tween goes all the way back to the beginning, we need to revert it to the OLD/ORIGINAL value (with those units). We record that as a \"b\" (beginning) property and point to a render method that handles that. (performance optimization)\n            this._pt.b = startValue;\n            this._pt.r = _renderCSSPropWithBeginning;\n          }\n        } else if (!(p in style)) {\n          if (p in target) {\n            //maybe it's not a style - it could be a property added directly to an element in which case we'll try to animate that.\n            this.add(target, p, startValue || target[p], relative ? relative + endValue : endValue, index, targets);\n          } else if (p !== \"parseTransform\") {\n            _missingPlugin(p, endValue);\n\n            continue;\n          }\n        } else {\n          _tweenComplexCSSString.call(this, target, p, startValue, relative ? relative + endValue : endValue);\n        }\n\n        isTransformRelated || (p in style ? inlineProps.push(p, 0, style[p]) : inlineProps.push(p, 1, startValue || target[p]));\n        props.push(p);\n      }\n    }\n\n    hasPriority && _sortPropTweensByPriority(this);\n  },\n  render: function render(ratio, data) {\n    if (data.tween._time || !_reverting()) {\n      var pt = data._pt;\n\n      while (pt) {\n        pt.r(ratio, pt.d);\n        pt = pt._next;\n      }\n    } else {\n      data.styles.revert();\n    }\n  },\n  get: _get,\n  aliases: _propertyAliases,\n  getSetter: function getSetter(target, property, plugin) {\n    //returns a setter function that accepts target, property, value and applies it accordingly. Remember, properties like \"x\" aren't as simple as target.style.property = value because they've got to be applied to a proxy object and then merged into a transform string in a renderer.\n    var p = _propertyAliases[property];\n    p && p.indexOf(\",\") < 0 && (property = p);\n    return property in _transformProps && property !== _transformOriginProp && (target._gsap.x || _get(target, \"x\")) ? plugin && _recentSetterPlugin === plugin ? property === \"scale\" ? _setterScale : _setterTransform : (_recentSetterPlugin = plugin || {}) && (property === \"scale\" ? _setterScaleWithRender : _setterTransformWithRender) : target.style && !_isUndefined(target.style[property]) ? _setterCSSStyle : ~property.indexOf(\"-\") ? _setterCSSProp : _getSetter(target, property);\n  },\n  core: {\n    _removeProperty: _removeProperty,\n    _getMatrix: _getMatrix\n  }\n};\ngsap.utils.checkPrefix = _checkPropPrefix;\ngsap.core.getStyleSaver = _getStyleSaver;\n\n(function (positionAndScale, rotation, others, aliases) {\n  var all = _forEachName(positionAndScale + \",\" + rotation + \",\" + others, function (name) {\n    _transformProps[name] = 1;\n  });\n\n  _forEachName(rotation, function (name) {\n    _config.units[name] = \"deg\";\n    _rotationalProperties[name] = 1;\n  });\n\n  _propertyAliases[all[13]] = positionAndScale + \",\" + rotation;\n\n  _forEachName(aliases, function (name) {\n    var split = name.split(\":\");\n    _propertyAliases[split[1]] = all[split[0]];\n  });\n})(\"x,y,z,scale,scaleX,scaleY,xPercent,yPercent\", \"rotation,rotationX,rotationY,skewX,skewY\", \"transform,transformOrigin,svgOrigin,force3D,smoothOrigin,transformPerspective\", \"0:translateX,1:translateY,2:translateZ,8:rotate,8:rotationZ,8:rotateZ,9:rotateX,10:rotateY\");\n\n_forEachName(\"x,y,z,top,right,bottom,left,width,height,fontSize,padding,margin,perspective\", function (name) {\n  _config.units[name] = \"px\";\n});\n\ngsap.registerPlugin(CSSPlugin);\nexport { CSSPlugin as default, _getBBox, _createElement, _checkPropPrefix as checkPrefix };","import { gsap, Power0, Power1, Power2, Power3, Power4, Linear, Quad, Cubic, Quart, Quint, Strong, Elastic, Back, SteppedEase, Bounce, Sine, Expo, Circ, TweenLite, TimelineLite, TimelineMax } from \"./gsap-core.js\";\nimport { CSSPlugin } from \"./CSSPlugin.js\";\nvar gsapWithCSS = gsap.registerPlugin(CSSPlugin) || gsap,\n    // to protect from tree shaking\nTweenMaxWithCSS = gsapWithCSS.core.Tween;\nexport { gsapWithCSS as gsap, gsapWithCSS as default, CSSPlugin, TweenMaxWithCSS as TweenMax, TweenLite, TimelineMax, TimelineLite, Power0, Power1, Power2, Power3, Power4, Linear, Quad, Cubic, Quart, Quint, Strong, Elastic, Back, SteppedEase, Bounce, Sine, Expo, Circ };","function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n/*!\n * Observer 3.12.5\n * https://gsap.com\n *\n * @license Copyright 2008-2024, GreenSock. All rights reserved.\n * Subject to the terms at https://gsap.com/standard-license or for\n * Club GSAP members, the agreement issued with that membership.\n * @author: Jack Doyle, jack@greensock.com\n*/\n\n/* eslint-disable */\nvar gsap,\n    _coreInitted,\n    _clamp,\n    _win,\n    _doc,\n    _docEl,\n    _body,\n    _isTouch,\n    _pointerType,\n    ScrollTrigger,\n    _root,\n    _normalizer,\n    _eventTypes,\n    _context,\n    _getGSAP = function _getGSAP() {\n  return gsap || typeof window !== \"undefined\" && (gsap = window.gsap) && gsap.registerPlugin && gsap;\n},\n    _startup = 1,\n    _observers = [],\n    _scrollers = [],\n    _proxies = [],\n    _getTime = Date.now,\n    _bridge = function _bridge(name, value) {\n  return value;\n},\n    _integrate = function _integrate() {\n  var core = ScrollTrigger.core,\n      data = core.bridge || {},\n      scrollers = core._scrollers,\n      proxies = core._proxies;\n  scrollers.push.apply(scrollers, _scrollers);\n  proxies.push.apply(proxies, _proxies);\n  _scrollers = scrollers;\n  _proxies = proxies;\n\n  _bridge = function _bridge(name, value) {\n    return data[name](value);\n  };\n},\n    _getProxyProp = function _getProxyProp(element, property) {\n  return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];\n},\n    _isViewport = function _isViewport(el) {\n  return !!~_root.indexOf(el);\n},\n    _addListener = function _addListener(element, type, func, passive, capture) {\n  return element.addEventListener(type, func, {\n    passive: passive !== false,\n    capture: !!capture\n  });\n},\n    _removeListener = function _removeListener(element, type, func, capture) {\n  return element.removeEventListener(type, func, !!capture);\n},\n    _scrollLeft = \"scrollLeft\",\n    _scrollTop = \"scrollTop\",\n    _onScroll = function _onScroll() {\n  return _normalizer && _normalizer.isPressed || _scrollers.cache++;\n},\n    _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {\n  var cachingFunc = function cachingFunc(value) {\n    // since reading the scrollTop/scrollLeft/pageOffsetY/pageOffsetX can trigger a layout, this function allows us to cache the value so it only gets read fresh after a \"scroll\" event fires (or while we're refreshing because that can lengthen the page and alter the scroll position). when \"soft\" is true, that means don't actually set the scroll, but cache the new value instead (useful in ScrollSmoother)\n    if (value || value === 0) {\n      _startup && (_win.history.scrollRestoration = \"manual\"); // otherwise the new position will get overwritten by the browser onload.\n\n      var isNormalizing = _normalizer && _normalizer.isPressed;\n      value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0); //TODO: iOS Bug: if you allow it to go to 0, Safari can start to report super strange (wildly inaccurate) touch positions!\n\n      f(value);\n      cachingFunc.cacheID = _scrollers.cache;\n      isNormalizing && _bridge(\"ss\", value); // set scroll (notify ScrollTrigger so it can dispatch a \"scrollStart\" event if necessary\n    } else if (doNotCache || _scrollers.cache !== cachingFunc.cacheID || _bridge(\"ref\")) {\n      cachingFunc.cacheID = _scrollers.cache;\n      cachingFunc.v = f();\n    }\n\n    return cachingFunc.v + cachingFunc.offset;\n  };\n\n  cachingFunc.offset = 0;\n  return f && cachingFunc;\n},\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: _scrollCacheFunc(function (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: _scrollCacheFunc(function (value) {\n    return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;\n  })\n},\n    _getTarget = function _getTarget(t, self) {\n  return (self && self._ctx && self._ctx.selector || gsap.utils.toArray)(t)[0] || (typeof t === \"string\" && gsap.config().nullTargetWarn !== false ? console.warn(\"Element not found:\", t) : null);\n},\n    _getScrollFunc = function _getScrollFunc(element, _ref) {\n  var s = _ref.s,\n      sc = _ref.sc;\n  // we store the scroller functions in an alternating sequenced Array like [element, verticalScrollFunc, horizontalScrollFunc, ...] so that we can minimize memory, maximize performance, and we also record the last position as a \".rec\" property in order to revert to that after refreshing to ensure things don't shift around.\n  _isViewport(element) && (element = _doc.scrollingElement || _docEl);\n\n  var i = _scrollers.indexOf(element),\n      offset = sc === _vertical.sc ? 1 : 2;\n\n  !~i && (i = _scrollers.push(element) - 1);\n  _scrollers[i + offset] || _addListener(element, \"scroll\", _onScroll); // clear the cache when a scroll occurs\n\n  var prev = _scrollers[i + offset],\n      func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {\n    return arguments.length ? element[s] = value : element[s];\n  })));\n  func.target = element;\n  prev || (func.smooth = gsap.getProperty(element, \"scrollBehavior\") === \"smooth\"); // only set it the first time (don't reset every time a scrollFunc is requested because perhaps it happens during a refresh() when it's disabled in ScrollTrigger.\n\n  return func;\n},\n    _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {\n  var v1 = value,\n      v2 = value,\n      t1 = _getTime(),\n      t2 = t1,\n      min = minTimeRefresh || 50,\n      dropToZeroTime = Math.max(500, min * 3),\n      update = function update(value, force) {\n    var t = _getTime();\n\n    if (force || t - t1 > min) {\n      v2 = v1;\n      v1 = value;\n      t2 = t1;\n      t1 = t;\n    } else if (useDelta) {\n      v1 += value;\n    } else {\n      // not totally necessary, but makes it a bit more accurate by adjusting the v1 value according to the new slope. This way we're not just ignoring the incoming data. Removing for now because it doesn't seem to make much practical difference and it's probably not worth the kb.\n      v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);\n    }\n  },\n      reset = function reset() {\n    v2 = v1 = useDelta ? 0 : v1;\n    t2 = t1 = 0;\n  },\n      getVelocity = function getVelocity(latestValue) {\n    var tOld = t2,\n        vOld = v2,\n        t = _getTime();\n\n    (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);\n    return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;\n  };\n\n  return {\n    update: update,\n    reset: reset,\n    getVelocity: getVelocity\n  };\n},\n    _getEvent = function _getEvent(e, preventDefault) {\n  preventDefault && !e._gsapAllow && e.preventDefault();\n  return e.changedTouches ? e.changedTouches[0] : e;\n},\n    _getAbsoluteMax = function _getAbsoluteMax(a) {\n  var max = Math.max.apply(Math, a),\n      min = Math.min.apply(Math, a);\n  return Math.abs(max) >= Math.abs(min) ? max : min;\n},\n    _setScrollTrigger = function _setScrollTrigger() {\n  ScrollTrigger = gsap.core.globals().ScrollTrigger;\n  ScrollTrigger && ScrollTrigger.core && _integrate();\n},\n    _initCore = function _initCore(core) {\n  gsap = core || _getGSAP();\n\n  if (!_coreInitted && gsap && typeof document !== \"undefined\" && document.body) {\n    _win = window;\n    _doc = document;\n    _docEl = _doc.documentElement;\n    _body = _doc.body;\n    _root = [_win, _doc, _docEl, _body];\n    _clamp = gsap.utils.clamp;\n\n    _context = gsap.core.context || function () {};\n\n    _pointerType = \"onpointerenter\" in _body ? \"pointer\" : \"mouse\"; // isTouch is 0 if no touch, 1 if ONLY touch, and 2 if it can accommodate touch but also other types like mouse/pointer.\n\n    _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia(\"(hover: none), (pointer: coarse)\").matches ? 1 : \"ontouchstart\" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;\n    _eventTypes = Observer.eventTypes = (\"ontouchstart\" in _docEl ? \"touchstart,touchmove,touchcancel,touchend\" : !(\"onpointerdown\" in _docEl) ? \"mousedown,mousemove,mouseup,mouseup\" : \"pointerdown,pointermove,pointercancel,pointerup\").split(\",\");\n    setTimeout(function () {\n      return _startup = 0;\n    }, 500);\n\n    _setScrollTrigger();\n\n    _coreInitted = 1;\n  }\n\n  return _coreInitted;\n};\n\n_horizontal.op = _vertical;\n_scrollers.cache = 0;\nexport var Observer = /*#__PURE__*/function () {\n  function Observer(vars) {\n    this.init(vars);\n  }\n\n  var _proto = Observer.prototype;\n\n  _proto.init = function init(vars) {\n    _coreInitted || _initCore(gsap) || console.warn(\"Please gsap.registerPlugin(Observer)\");\n    ScrollTrigger || _setScrollTrigger();\n    var tolerance = vars.tolerance,\n        dragMinimum = vars.dragMinimum,\n        type = vars.type,\n        target = vars.target,\n        lineHeight = vars.lineHeight,\n        debounce = vars.debounce,\n        preventDefault = vars.preventDefault,\n        onStop = vars.onStop,\n        onStopDelay = vars.onStopDelay,\n        ignore = vars.ignore,\n        wheelSpeed = vars.wheelSpeed,\n        event = vars.event,\n        onDragStart = vars.onDragStart,\n        onDragEnd = vars.onDragEnd,\n        onDrag = vars.onDrag,\n        onPress = vars.onPress,\n        onRelease = vars.onRelease,\n        onRight = vars.onRight,\n        onLeft = vars.onLeft,\n        onUp = vars.onUp,\n        onDown = vars.onDown,\n        onChangeX = vars.onChangeX,\n        onChangeY = vars.onChangeY,\n        onChange = vars.onChange,\n        onToggleX = vars.onToggleX,\n        onToggleY = vars.onToggleY,\n        onHover = vars.onHover,\n        onHoverEnd = vars.onHoverEnd,\n        onMove = vars.onMove,\n        ignoreCheck = vars.ignoreCheck,\n        isNormalizer = vars.isNormalizer,\n        onGestureStart = vars.onGestureStart,\n        onGestureEnd = vars.onGestureEnd,\n        onWheel = vars.onWheel,\n        onEnable = vars.onEnable,\n        onDisable = vars.onDisable,\n        onClick = vars.onClick,\n        scrollSpeed = vars.scrollSpeed,\n        capture = vars.capture,\n        allowClicks = vars.allowClicks,\n        lockAxis = vars.lockAxis,\n        onLockAxis = vars.onLockAxis;\n    this.target = target = _getTarget(target) || _docEl;\n    this.vars = vars;\n    ignore && (ignore = gsap.utils.toArray(ignore));\n    tolerance = tolerance || 1e-9;\n    dragMinimum = dragMinimum || 0;\n    wheelSpeed = wheelSpeed || 1;\n    scrollSpeed = scrollSpeed || 1;\n    type = type || \"wheel,touch,pointer\";\n    debounce = debounce !== false;\n    lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22); // note: browser may report \"normal\", so default to 22.\n\n    var id,\n        onStopDelayedCall,\n        dragged,\n        moved,\n        wheeled,\n        locked,\n        axis,\n        self = this,\n        prevDeltaX = 0,\n        prevDeltaY = 0,\n        passive = vars.passive || !preventDefault,\n        scrollFuncX = _getScrollFunc(target, _horizontal),\n        scrollFuncY = _getScrollFunc(target, _vertical),\n        scrollX = scrollFuncX(),\n        scrollY = scrollFuncY(),\n        limitToTouch = ~type.indexOf(\"touch\") && !~type.indexOf(\"pointer\") && _eventTypes[0] === \"pointerdown\",\n        // for devices that accommodate mouse events and touch events, we need to distinguish.\n    isViewport = _isViewport(target),\n        ownerDoc = target.ownerDocument || _doc,\n        deltaX = [0, 0, 0],\n        // wheel, scroll, pointer/touch\n    deltaY = [0, 0, 0],\n        onClickTime = 0,\n        clickCapture = function clickCapture() {\n      return onClickTime = _getTime();\n    },\n        _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {\n      return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== \"touch\" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);\n    },\n        onStopFunc = function onStopFunc() {\n      self._vx.reset();\n\n      self._vy.reset();\n\n      onStopDelayedCall.pause();\n      onStop && onStop(self);\n    },\n        update = function update() {\n      var dx = self.deltaX = _getAbsoluteMax(deltaX),\n          dy = self.deltaY = _getAbsoluteMax(deltaY),\n          changedX = Math.abs(dx) >= tolerance,\n          changedY = Math.abs(dy) >= tolerance;\n\n      onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY); // in ScrollTrigger.normalizeScroll(), we need to know if it was touch/pointer so we need access to the deltaX/deltaY Arrays before we clear them out.\n\n      if (changedX) {\n        onRight && self.deltaX > 0 && onRight(self);\n        onLeft && self.deltaX < 0 && onLeft(self);\n        onChangeX && onChangeX(self);\n        onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);\n        prevDeltaX = self.deltaX;\n        deltaX[0] = deltaX[1] = deltaX[2] = 0;\n      }\n\n      if (changedY) {\n        onDown && self.deltaY > 0 && onDown(self);\n        onUp && self.deltaY < 0 && onUp(self);\n        onChangeY && onChangeY(self);\n        onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);\n        prevDeltaY = self.deltaY;\n        deltaY[0] = deltaY[1] = deltaY[2] = 0;\n      }\n\n      if (moved || dragged) {\n        onMove && onMove(self);\n\n        if (dragged) {\n          onDrag(self);\n          dragged = false;\n        }\n\n        moved = false;\n      }\n\n      locked && !(locked = false) && onLockAxis && onLockAxis(self);\n\n      if (wheeled) {\n        onWheel(self);\n        wheeled = false;\n      }\n\n      id = 0;\n    },\n        onDelta = function onDelta(x, y, index) {\n      deltaX[index] += x;\n      deltaY[index] += y;\n\n      self._vx.update(x);\n\n      self._vy.update(y);\n\n      debounce ? id || (id = requestAnimationFrame(update)) : update();\n    },\n        onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {\n      if (lockAxis && !axis) {\n        self.axis = axis = Math.abs(x) > Math.abs(y) ? \"x\" : \"y\";\n        locked = true;\n      }\n\n      if (axis !== \"y\") {\n        deltaX[2] += x;\n\n        self._vx.update(x, true); // update the velocity as frequently as possible instead of in the debounced function so that very quick touch-scrolls (flicks) feel natural. If it's the mouse/touch/pointer, force it so that we get snappy/accurate momentum scroll.\n\n      }\n\n      if (axis !== \"x\") {\n        deltaY[2] += y;\n\n        self._vy.update(y, true);\n      }\n\n      debounce ? id || (id = requestAnimationFrame(update)) : update();\n    },\n        _onDrag = function _onDrag(e) {\n      if (_ignoreCheck(e, 1)) {\n        return;\n      }\n\n      e = _getEvent(e, preventDefault);\n      var x = e.clientX,\n          y = e.clientY,\n          dx = x - self.x,\n          dy = y - self.y,\n          isDragging = self.isDragging;\n      self.x = x;\n      self.y = y;\n\n      if (isDragging || Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum) {\n        onDrag && (dragged = true);\n        isDragging || (self.isDragging = true);\n        onTouchOrPointerDelta(dx, dy);\n        isDragging || onDragStart && onDragStart(self);\n      }\n    },\n        _onPress = self.onPress = function (e) {\n      if (_ignoreCheck(e, 1) || e && e.button) {\n        return;\n      }\n\n      self.axis = axis = null;\n      onStopDelayedCall.pause();\n      self.isPressed = true;\n      e = _getEvent(e); // note: may need to preventDefault(?) Won't side-scroll on iOS Safari if we do, though.\n\n      prevDeltaX = prevDeltaY = 0;\n      self.startX = self.x = e.clientX;\n      self.startY = self.y = e.clientY;\n\n      self._vx.reset(); // otherwise the t2 may be stale if the user touches and flicks super fast and releases in less than 2 requestAnimationFrame ticks, causing velocity to be 0.\n\n\n      self._vy.reset();\n\n      _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);\n\n      self.deltaX = self.deltaY = 0;\n      onPress && onPress(self);\n    },\n        _onRelease = self.onRelease = function (e) {\n      if (_ignoreCheck(e, 1)) {\n        return;\n      }\n\n      _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);\n\n      var isTrackingDrag = !isNaN(self.y - self.startY),\n          wasDragging = self.isDragging,\n          isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),\n          // some touch devices need some wiggle room in terms of sensing clicks - the finger may move a few pixels.\n      eventData = _getEvent(e);\n\n      if (!isDragNotClick && isTrackingDrag) {\n        self._vx.reset();\n\n        self._vy.reset(); //if (preventDefault && allowClicks && self.isPressed) { // check isPressed because in a rare edge case, the inputObserver in ScrollTrigger may stopPropagation() on the press/drag, so the onRelease may get fired without the onPress/onDrag ever getting called, thus it could trigger a click to occur on a link after scroll-dragging it.\n\n\n        if (preventDefault && allowClicks) {\n          gsap.delayedCall(0.08, function () {\n            // some browsers (like Firefox) won't trust script-generated clicks, so if the user tries to click on a video to play it, for example, it simply won't work. Since a regular \"click\" event will most likely be generated anyway (one that has its isTrusted flag set to true), we must slightly delay our script-generated click so that the \"real\"/trusted one is prioritized. Remember, when there are duplicate events in quick succession, we suppress all but the first one. Some browsers don't even trigger the \"real\" one at all, so our synthetic one is a safety valve that ensures that no matter what, a click event does get dispatched.\n            if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {\n              if (e.target.click) {\n                //some browsers (like mobile Safari) don't properly trigger the click event\n                e.target.click();\n              } else if (ownerDoc.createEvent) {\n                var syntheticEvent = ownerDoc.createEvent(\"MouseEvents\");\n                syntheticEvent.initMouseEvent(\"click\", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);\n                e.target.dispatchEvent(syntheticEvent);\n              }\n            }\n          });\n        }\n      }\n\n      self.isDragging = self.isGesturing = self.isPressed = false;\n      onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);\n      onDragEnd && wasDragging && onDragEnd(self);\n      onRelease && onRelease(self, isDragNotClick);\n    },\n        _onGestureStart = function _onGestureStart(e) {\n      return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);\n    },\n        _onGestureEnd = function _onGestureEnd() {\n      return (self.isGesturing = false) || onGestureEnd(self);\n    },\n        onScroll = function onScroll(e) {\n      if (_ignoreCheck(e)) {\n        return;\n      }\n\n      var x = scrollFuncX(),\n          y = scrollFuncY();\n      onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);\n      scrollX = x;\n      scrollY = y;\n      onStop && onStopDelayedCall.restart(true);\n    },\n        _onWheel = function _onWheel(e) {\n      if (_ignoreCheck(e)) {\n        return;\n      }\n\n      e = _getEvent(e, preventDefault);\n      onWheel && (wheeled = true);\n      var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;\n      onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);\n      onStop && !isNormalizer && onStopDelayedCall.restart(true);\n    },\n        _onMove = function _onMove(e) {\n      if (_ignoreCheck(e)) {\n        return;\n      }\n\n      var x = e.clientX,\n          y = e.clientY,\n          dx = x - self.x,\n          dy = y - self.y;\n      self.x = x;\n      self.y = y;\n      moved = true;\n      onStop && onStopDelayedCall.restart(true);\n      (dx || dy) && onTouchOrPointerDelta(dx, dy);\n    },\n        _onHover = function _onHover(e) {\n      self.event = e;\n      onHover(self);\n    },\n        _onHoverEnd = function _onHoverEnd(e) {\n      self.event = e;\n      onHoverEnd(self);\n    },\n        _onClick = function _onClick(e) {\n      return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);\n    };\n\n    onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();\n    self.deltaX = self.deltaY = 0;\n    self._vx = _getVelocityProp(0, 50, true);\n    self._vy = _getVelocityProp(0, 50, true);\n    self.scrollX = scrollFuncX;\n    self.scrollY = scrollFuncY;\n    self.isDragging = self.isGesturing = self.isPressed = false;\n\n    _context(this);\n\n    self.enable = function (e) {\n      if (!self.isEnabled) {\n        _addListener(isViewport ? ownerDoc : target, \"scroll\", _onScroll);\n\n        type.indexOf(\"scroll\") >= 0 && _addListener(isViewport ? ownerDoc : target, \"scroll\", onScroll, passive, capture);\n        type.indexOf(\"wheel\") >= 0 && _addListener(target, \"wheel\", _onWheel, passive, capture);\n\n        if (type.indexOf(\"touch\") >= 0 && _isTouch || type.indexOf(\"pointer\") >= 0) {\n          _addListener(target, _eventTypes[0], _onPress, passive, capture);\n\n          _addListener(ownerDoc, _eventTypes[2], _onRelease);\n\n          _addListener(ownerDoc, _eventTypes[3], _onRelease);\n\n          allowClicks && _addListener(target, \"click\", clickCapture, true, true);\n          onClick && _addListener(target, \"click\", _onClick);\n          onGestureStart && _addListener(ownerDoc, \"gesturestart\", _onGestureStart);\n          onGestureEnd && _addListener(ownerDoc, \"gestureend\", _onGestureEnd);\n          onHover && _addListener(target, _pointerType + \"enter\", _onHover);\n          onHoverEnd && _addListener(target, _pointerType + \"leave\", _onHoverEnd);\n          onMove && _addListener(target, _pointerType + \"move\", _onMove);\n        }\n\n        self.isEnabled = true;\n        e && e.type && _onPress(e);\n        onEnable && onEnable(self);\n      }\n\n      return self;\n    };\n\n    self.disable = function () {\n      if (self.isEnabled) {\n        // only remove the _onScroll listener if there aren't any others that rely on the functionality.\n        _observers.filter(function (o) {\n          return o !== self && _isViewport(o.target);\n        }).length || _removeListener(isViewport ? ownerDoc : target, \"scroll\", _onScroll);\n\n        if (self.isPressed) {\n          self._vx.reset();\n\n          self._vy.reset();\n\n          _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);\n        }\n\n        _removeListener(isViewport ? ownerDoc : target, \"scroll\", onScroll, capture);\n\n        _removeListener(target, \"wheel\", _onWheel, capture);\n\n        _removeListener(target, _eventTypes[0], _onPress, capture);\n\n        _removeListener(ownerDoc, _eventTypes[2], _onRelease);\n\n        _removeListener(ownerDoc, _eventTypes[3], _onRelease);\n\n        _removeListener(target, \"click\", clickCapture, true);\n\n        _removeListener(target, \"click\", _onClick);\n\n        _removeListener(ownerDoc, \"gesturestart\", _onGestureStart);\n\n        _removeListener(ownerDoc, \"gestureend\", _onGestureEnd);\n\n        _removeListener(target, _pointerType + \"enter\", _onHover);\n\n        _removeListener(target, _pointerType + \"leave\", _onHoverEnd);\n\n        _removeListener(target, _pointerType + \"move\", _onMove);\n\n        self.isEnabled = self.isPressed = self.isDragging = false;\n        onDisable && onDisable(self);\n      }\n    };\n\n    self.kill = self.revert = function () {\n      self.disable();\n\n      var i = _observers.indexOf(self);\n\n      i >= 0 && _observers.splice(i, 1);\n      _normalizer === self && (_normalizer = 0);\n    };\n\n    _observers.push(self);\n\n    isNormalizer && _isViewport(target) && (_normalizer = self);\n    self.enable(event);\n  };\n\n  _createClass(Observer, [{\n    key: \"velocityX\",\n    get: function get() {\n      return this._vx.getVelocity();\n    }\n  }, {\n    key: \"velocityY\",\n    get: function get() {\n      return this._vy.getVelocity();\n    }\n  }]);\n\n  return Observer;\n}();\nObserver.version = \"3.12.5\";\n\nObserver.create = function (vars) {\n  return new Observer(vars);\n};\n\nObserver.register = _initCore;\n\nObserver.getAll = function () {\n  return _observers.slice();\n};\n\nObserver.getById = function (id) {\n  return _observers.filter(function (o) {\n    return o.vars.id === id;\n  })[0];\n};\n\n_getGSAP() && gsap.registerPlugin(Observer);\nexport { Observer as default, _isViewport, _scrollers, _getScrollFunc, _getProxyProp, _proxies, _getVelocityProp, _vertical, _horizontal, _getTarget };","/*!\n * ScrollTrigger 3.12.5\n * https://gsap.com\n *\n * @license Copyright 2008-2024, GreenSock. All rights reserved.\n * Subject to the terms at https://gsap.com/standard-license or for\n * Club GSAP members, the agreement issued with that membership.\n * @author: Jack Doyle, jack@greensock.com\n*/\n\n/* eslint-disable */\nimport { Observer, _getTarget, _vertical, _horizontal, _scrollers, _proxies, _getScrollFunc, _getProxyProp, _getVelocityProp } from \"./Observer.js\";\n\nvar gsap,\n    _coreInitted,\n    _win,\n    _doc,\n    _docEl,\n    _body,\n    _root,\n    _resizeDelay,\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    _normalizer,\n    _ignoreMobileResize,\n    _baseScreenHeight,\n    _baseScreenWidth,\n    _fixIOSBug,\n    _context,\n    _scrollRestoration,\n    _div100vh,\n    _100vh,\n    _isReverted,\n    _clampingMax,\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    _getTime = Date.now,\n    _time1 = _getTime(),\n    _lastScrollTime = 0,\n    _enabled = 0,\n    _parseClamp = function _parseClamp(value, type, self) {\n  var clamp = _isString(value) && (value.substr(0, 6) === \"clamp(\" || value.indexOf(\"max\") > -1);\n  self[\"_\" + type + \"Clamp\"] = clamp;\n  return clamp ? value.substr(6, value.length - 7) : value;\n},\n    _keepClamp = function _keepClamp(value, clamp) {\n  return clamp && (!_isString(value) || value.substr(0, 6) !== \"clamp(\") ? \"clamp(\" + value + \")\" : value;\n},\n    _rafBugFix = function _rafBugFix() {\n  return _enabled && requestAnimationFrame(_rafBugFix);\n},\n    // in some browsers (like Firefox), screen repaints weren't consistent unless we had SOMETHING queued up in requestAnimationFrame()! So this just creates a super simple loop to keep it alive and smooth out repaints.\n_pointerDownHandler = function _pointerDownHandler() {\n  return _pointerIsDown = 1;\n},\n    _pointerUpHandler = function _pointerUpHandler() {\n  return _pointerIsDown = 0;\n},\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    _getViewportDimension = function _getViewportDimension(dimensionProperty) {\n  return (dimensionProperty === \"Height\" ? _100vh : _win[\"inner\" + dimensionProperty]) || _docEl[\"client\" + dimensionProperty] || _body[\"client\" + dimensionProperty];\n},\n    _getBoundsFunc = function _getBoundsFunc(element) {\n  return _getProxyProp(element, \"getBoundingClientRect\") || (_isViewport(element) ? function () {\n    _winOffsets.width = _win.innerWidth;\n    _winOffsets.height = _100vh;\n    return _winOffsets;\n  } : function () {\n    return _getBounds(element);\n  });\n},\n    _getSizeFunc = function _getSizeFunc(scroller, isViewport, _ref) {\n  var d = _ref.d,\n      d2 = _ref.d2,\n      a = _ref.a;\n  return (a = _getProxyProp(scroller, \"getBoundingClientRect\")) ? function () {\n    return a()[d];\n  } : function () {\n    return (isViewport ? _getViewportDimension(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, _ref2) {\n  var s = _ref2.s,\n      d2 = _ref2.d2,\n      d = _ref2.d,\n      a = _ref2.a;\n  return Math.max(0, (s = \"scroll\" + d2) && (a = _getProxyProp(element, s)) ? a() - _getBoundsFunc(element)()[d] : _isViewport(element) ? (_docEl[s] || _body[s]) - _getViewportDimension(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    _endAnimation = function _endAnimation(animation, reversed, pause) {\n  return animation && animation.progress(reversed ? 0 : 1) && pause && animation.pause();\n},\n    _callback = function _callback(self, func) {\n  if (self.enabled) {\n    var result = self._ctx ? self._ctx.add(function () {\n      return func(self);\n    }) : func(self);\n    result && result.totalTime && (self.callbackAnimation = result);\n  }\n},\n    _abs = Math.abs,\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    _getComputedStyle = function _getComputedStyle(element) {\n  return _win.getComputedStyle(element);\n},\n    _makePositionable = function _makePositionable(element) {\n  // if the element already has position: absolute or fixed, leave that, otherwise make it position: relative\n  var position = _getComputedStyle(element).position;\n\n  element.style.position = position === \"absolute\" || position === \"fixed\" ? position : \"relative\";\n},\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    _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, _ref3) {\n  var d2 = _ref3.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    _snapDirectional = function _snapDirectional(snapIncrementOrArray) {\n  var snap = gsap.utils.snap(snapIncrementOrArray),\n      a = Array.isArray(snapIncrementOrArray) && snapIncrementOrArray.slice(0).sort(function (a, b) {\n    return a - b;\n  });\n  return a ? function (value, direction, threshold) {\n    if (threshold === void 0) {\n      threshold = 1e-3;\n    }\n\n    var i;\n\n    if (!direction) {\n      return snap(value);\n    }\n\n    if (direction > 0) {\n      value -= threshold; // 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[i - 1];\n    } else {\n      i = a.length;\n      value += threshold;\n\n      while (i--) {\n        if (a[i] <= value) {\n          return a[i];\n        }\n      }\n    }\n\n    return a[0];\n  } : function (value, direction, threshold) {\n    if (threshold === void 0) {\n      threshold = 1e-3;\n    }\n\n    var snapped = snap(value);\n    return !direction || Math.abs(snapped - value) < threshold || snapped - value < 0 === direction < 0 ? snapped : snap(direction < 0 ? value - snapIncrementOrArray : value + snapIncrementOrArray);\n  };\n},\n    _getLabelAtDirection = function _getLabelAtDirection(timeline) {\n  return function (value, st) {\n    return _snapDirectional(_getLabelRatioArray(timeline))(value, st.direction);\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, nonPassive, capture) {\n  return element.addEventListener(type, func, {\n    passive: !nonPassive,\n    capture: !!capture\n  });\n},\n    _removeListener = function _removeListener(element, type, func, capture) {\n  return element.removeEventListener(type, func, !!capture);\n},\n    _wheelListener = function _wheelListener(func, el, scrollFunc) {\n  scrollFunc = scrollFunc && scrollFunc.wheelHandler;\n\n  if (scrollFunc) {\n    func(el, \"wheel\", scrollFunc);\n    func(el, \"touchmove\", scrollFunc);\n  }\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, _ref4, offset, matchWidthEl, containerAnimation) {\n  var startColor = _ref4.startColor,\n      endColor = _ref4.endColor,\n      fontSize = _ref4.fontSize,\n      indent = _ref4.indent,\n      fontWeight = _ref4.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 || containerAnimation) && useFixedPosition ? \"fixed;\" : \"absolute;\");\n  (isScroller || containerAnimation || !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 + (name ? \" marker-\" + name : \"\"));\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    _rafID,\n    _sync = function _sync() {\n  return _getTime() - _lastScrollTime > 34 && (_rafID || (_rafID = requestAnimationFrame(_updateAll)));\n},\n    _onScroll = function _onScroll() {\n  // previously, we tried to optimize performance by batching/deferring to the next requestAnimationFrame(), but discovered that Safari has a few bugs that make this unworkable (especially on iOS). See https://codepen.io/GreenSock/pen/16c435b12ef09c38125204818e7b45fc?editors=0010 and https://codepen.io/GreenSock/pen/JjOxYpQ/3dd65ccec5a60f1d862c355d84d14562?editors=0010 and https://codepen.io/GreenSock/pen/ExbrPNa/087cef197dc35445a0951e8935c41503?editors=0010\n  if (!_normalizer || !_normalizer.isPressed || _normalizer.startX > _body.clientWidth) {\n    // if the user is dragging the scrollbar, allow it.\n    _scrollers.cache++;\n\n    if (_normalizer) {\n      _rafID || (_rafID = requestAnimationFrame(_updateAll));\n    } else {\n      _updateAll(); // Safari in particular (on desktop) NEEDS the immediate update rather than waiting for a requestAnimationFrame() whereas iOS seems to benefit from waiting for the requestAnimationFrame() tick, at least when normalizing. See https://codepen.io/GreenSock/pen/qBYozqO?editors=0110\n\n    }\n\n    _lastScrollTime || _dispatch(\"scrollStart\");\n    _lastScrollTime = _getTime();\n  }\n},\n    _setBaseDimensions = function _setBaseDimensions() {\n  _baseScreenWidth = _win.innerWidth;\n  _baseScreenHeight = _win.innerHeight;\n},\n    _onResize = function _onResize() {\n  _scrollers.cache++;\n  !_refreshing && !_ignoreResize && !_doc.fullscreenElement && !_doc.webkitFullscreenElement && (!_ignoreMobileResize || _baseScreenWidth !== _win.innerWidth || Math.abs(_win.innerHeight - _baseScreenHeight) > _win.innerHeight * 0.25) && _resizeDelay.restart(true);\n},\n    // ignore resizes triggered by refresh()\n_listeners = {},\n    _emptyArray = [],\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 += 5) {\n    if (!media || _savedStyles[i + 4] && _savedStyles[i + 4].query === media) {\n      _savedStyles[i].style.cssText = _savedStyles[i + 1];\n      _savedStyles[i].getBBox && _savedStyles[i].setAttribute(\"transform\", _savedStyles[i + 2] || \"\");\n      _savedStyles[i + 3].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 (trigger && (!media || trigger._ctx === media)) {\n      if (kill) {\n        trigger.kill(1);\n      } else {\n        trigger.revert(true, true);\n      }\n    }\n  }\n\n  _isReverted = true;\n  media && _revertRecorded(media);\n  media || _dispatch(\"revert\");\n},\n    _clearScrollMemory = function _clearScrollMemory(scrollRestoration, force) {\n  // zero-out all the recorded scroll positions. Don't use _triggers because if, for example, .matchMedia() is used to create some ScrollTriggers and then the user resizes and it removes ALL ScrollTriggers, and then go back to a size where there are ScrollTriggers, it would have kept the position(s) saved from the initial state.\n  _scrollers.cache++;\n  (force || !_refreshingAll) && _scrollers.forEach(function (obj) {\n    return _isFunction(obj) && obj.cacheID++ && (obj.rec = 0);\n  });\n  _isString(scrollRestoration) && (_win.history.scrollRestoration = _scrollRestoration = scrollRestoration);\n},\n    _refreshingAll,\n    _refreshID = 0,\n    _queueRefreshID,\n    _queueRefreshAll = function _queueRefreshAll() {\n  // we don't want to call _refreshAll() every time we create a new ScrollTrigger (for performance reasons) - it's better to batch them. Some frameworks dynamically load content and we can't rely on the window's \"load\" or \"DOMContentLoaded\" events to trigger it.\n  if (_queueRefreshID !== _refreshID) {\n    var id = _queueRefreshID = _refreshID;\n    requestAnimationFrame(function () {\n      return id === _refreshID && _refreshAll(true);\n    });\n  }\n},\n    _refresh100vh = function _refresh100vh() {\n  _body.appendChild(_div100vh);\n\n  _100vh = !_normalizer && _div100vh.offsetHeight || _win.innerHeight;\n\n  _body.removeChild(_div100vh);\n},\n    _hideAllMarkers = function _hideAllMarkers(hide) {\n  return _toArray(\".gsap-marker-start, .gsap-marker-end, .gsap-marker-scroller-start, .gsap-marker-scroller-end\").forEach(function (el) {\n    return el.style.display = hide ? \"none\" : \"block\";\n  });\n},\n    _refreshAll = function _refreshAll(force, skipRevert) {\n  if (_lastScrollTime && !force && !_isReverted) {\n    _addListener(ScrollTrigger, \"scrollEnd\", _softRefresh);\n\n    return;\n  }\n\n  _refresh100vh();\n\n  _refreshingAll = ScrollTrigger.isRefreshing = true;\n\n  _scrollers.forEach(function (obj) {\n    return _isFunction(obj) && ++obj.cacheID && (obj.rec = obj());\n  }); // force the clearing of the cache because some browsers take a little while to dispatch the \"scroll\" event and the user may have changed the scroll position and then called ScrollTrigger.refresh() right away\n\n\n  var refreshInits = _dispatch(\"refreshInit\");\n\n  _sort && ScrollTrigger.sort();\n  skipRevert || _revertAll();\n\n  _scrollers.forEach(function (obj) {\n    if (_isFunction(obj)) {\n      obj.smooth && (obj.target.style.scrollBehavior = \"auto\"); // smooth scrolling interferes\n\n      obj(0);\n    }\n  });\n\n  _triggers.slice(0).forEach(function (t) {\n    return t.refresh();\n  }); // don't loop with _i because during a refresh() someone could call ScrollTrigger.update() which would iterate through _i resulting in a skip.\n\n\n  _isReverted = false;\n\n  _triggers.forEach(function (t) {\n    // nested pins (pinnedContainer) with pinSpacing may expand the container, so we must accommodate that here.\n    if (t._subPinOffset && t.pin) {\n      var prop = t.vars.horizontal ? \"offsetWidth\" : \"offsetHeight\",\n          original = t.pin[prop];\n      t.revert(true, 1);\n      t.adjustPinSpacing(t.pin[prop] - original);\n      t.refresh();\n    }\n  });\n\n  _clampingMax = 1; // pinSpacing might be propping a page open, thus when we .setPositions() to clamp a ScrollTrigger's end we should leave the pinSpacing alone. That's what this flag is for.\n\n  _hideAllMarkers(true);\n\n  _triggers.forEach(function (t) {\n    // the scroller's max scroll position may change after all the ScrollTriggers refreshed (like pinning could push it down), so we need to loop back and correct any with end: \"max\". Same for anything with a clamped end\n    var max = _maxScroll(t.scroller, t._dir),\n        endClamp = t.vars.end === \"max\" || t._endClamp && t.end > max,\n        startClamp = t._startClamp && t.start >= max;\n\n    (endClamp || startClamp) && t.setPositions(startClamp ? max - 1 : t.start, endClamp ? Math.max(startClamp ? max : t.start + 1, max) : t.end, true);\n  });\n\n  _hideAllMarkers(false);\n\n  _clampingMax = 0;\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  _scrollers.forEach(function (obj) {\n    if (_isFunction(obj)) {\n      obj.smooth && requestAnimationFrame(function () {\n        return obj.target.style.scrollBehavior = \"smooth\";\n      });\n      obj.rec && obj(obj.rec);\n    }\n  });\n\n  _clearScrollMemory(_scrollRestoration, 1);\n\n  _resizeDelay.pause();\n\n  _refreshID++;\n  _refreshingAll = 2;\n\n  _updateAll(2);\n\n  _triggers.forEach(function (t) {\n    return _isFunction(t.vars.onRefresh) && t.vars.onRefresh(t);\n  });\n\n  _refreshingAll = ScrollTrigger.isRefreshing = false;\n\n  _dispatch(\"refresh\");\n},\n    _lastScroll = 0,\n    _direction = 1,\n    _primary,\n    _updateAll = function _updateAll(force) {\n  if (force === 2 || !_refreshingAll && !_isReverted) {\n    // _isReverted could be true if, for example, a matchMedia() is in the process of executing. We don't want to update during the time everything is reverted.\n    ScrollTrigger.isUpdating = true;\n    _primary && _primary.update(0); // ScrollSmoother uses refreshPriority -9999 to become the primary that gets updated before all others because it affects the scroll position.\n\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    _refreshingAll || (_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    ScrollTrigger.isUpdating = false;\n  }\n\n  _rafID = 0;\n},\n    _propNamesToCopy = [_left, _top, _bottom, _right, _margin + _Bottom, _margin + _Right, _margin + _Top, _margin + _Left, \"display\", \"flexShrink\", \"float\", \"zIndex\", \"gridColumnStart\", \"gridColumnEnd\", \"gridRowStart\", \"gridRowEnd\", \"gridArea\", \"justifySelf\", \"alignSelf\", \"placeSelf\", \"order\"],\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  var cache = pin._gsap;\n\n  if (cache.spacerIsNative) {\n    _setState(cache.spacerState);\n  } else if (pin._gsap.swappedIn) {\n    var parent = spacer.parentNode;\n\n    if (parent) {\n      parent.insertBefore(pin, spacer);\n      parent.removeChild(spacer);\n    }\n  }\n\n  pin._gsap.swappedIn = false;\n},\n    _swapPinIn = function _swapPinIn(pin, spacer, cs, spacerState) {\n  if (!pin._gsap.swappedIn) {\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.flexBasis = cs.flexBasis || \"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\n    if (pin.parentNode !== spacer) {\n      pin.parentNode.insertBefore(spacer, pin);\n      spacer.appendChild(pin);\n    }\n\n    pin._gsap.swappedIn = true;\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    // // potential future feature (?) Allow users to calculate where a trigger hits (scroll position) like getScrollPosition(\"#id\", \"top bottom\")\n// _getScrollPosition = (trigger, position, {scroller, containerAnimation, horizontal}) => {\n// \tscroller = _getTarget(scroller || _win);\n// \tlet direction = horizontal ? _horizontal : _vertical,\n// \t\tisViewport = _isViewport(scroller);\n// \t_getSizeFunc(scroller, isViewport, direction);\n// \treturn _parsePosition(position, _getTarget(trigger), _getSizeFunc(scroller, isViewport, direction)(), direction, _getScrollFunc(scroller, direction)(), 0, 0, 0, _getOffsetsFunc(scroller, isViewport)(), isViewport ? 0 : parseFloat(_getComputedStyle(scroller)[\"border\" + direction.p2 + _Width]) || 0, 0, containerAnimation ? containerAnimation.duration() : _maxScroll(scroller), containerAnimation);\n// },\n_parsePosition = function _parsePosition(value, trigger, scrollerSize, direction, scroll, marker, markerScroller, self, scrollerBounds, borderWidth, useFixedPosition, scrollerMax, containerAnimation, clampZeroProp) {\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  var time = containerAnimation ? containerAnimation.time() : 0,\n      p1,\n      p2,\n      element;\n  containerAnimation && containerAnimation.seek(0);\n  isNaN(value) || (value = +value); // convert a string number like \"45\" to an actual number\n\n  if (!_isNumber(value)) {\n    _isFunction(trigger) && (trigger = trigger(self));\n    var offsets = (value || \"0\").split(\" \"),\n        bounds,\n        localOffset,\n        globalOffset,\n        display;\n    element = _getTarget(trigger, self) || _body;\n    bounds = _getBounds(element) || {};\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 {\n    containerAnimation && (value = gsap.utils.mapRange(containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, 0, scrollerMax, value));\n    markerScroller && _positionMarker(markerScroller, scrollerSize, direction, true);\n  }\n\n  if (clampZeroProp) {\n    self[clampZeroProp] = value || -0.001;\n    value < 0 && (value = 0);\n  }\n\n  if (marker) {\n    var position = value + scrollerSize,\n        isStart = marker._isStart;\n    p1 = \"scroll\" + direction.d2;\n\n    _positionMarker(marker, position, direction, isStart && position > 20 || !isStart && (useFixedPosition ? Math.max(_body[p1], _docEl[p1]) : marker.parentNode[p1]) <= 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  if (containerAnimation && element) {\n    p1 = _getBounds(element);\n    containerAnimation.seek(scrollerMax);\n    p2 = _getBounds(element);\n    containerAnimation._caScrollDist = p1[direction.p] - p2[direction.p];\n    value = value / containerAnimation._caScrollDist * scrollerMax;\n  }\n\n  containerAnimation && containerAnimation.seek(time);\n  return containerAnimation ? value : 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    _interruptionTracker = function _interruptionTracker(getValueFunc, initialValue, onInterrupt) {\n  var last1 = initialValue,\n      last2 = last1;\n  return function (value) {\n    var current = Math.round(getValueFunc()); // round because in some [very uncommon] Windows environments, scroll can get reported with decimals even though it was set without.\n\n    if (current !== last1 && current !== last2 && Math.abs(current - last1) > 3 && Math.abs(current - last2) > 3) {\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      value = current;\n      onInterrupt && onInterrupt();\n    }\n\n    last2 = last1;\n    last1 = value;\n    return value;\n  };\n},\n    _shiftMarker = function _shiftMarker(marker, direction, value) {\n  var vars = {};\n  vars[direction.p] = \"+=\" + value;\n  gsap.set(marker, vars);\n},\n    // _mergeAnimations = animations => {\n// \tlet tl = gsap.timeline({smoothChildTiming: true}).startTime(Math.min(...animations.map(a => a.globalTime(0))));\n// \tanimations.forEach(a => {let time = a.totalTime(); tl.add(a); a.totalTime(time); });\n// \ttl.smoothChildTiming = false;\n// \treturn tl;\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  getTween = function getTween(scrollTo, vars, initialValue, change1, change2) {\n    var tween = getTween.tween,\n        onComplete = vars.onComplete,\n        modifiers = {};\n    initialValue = initialValue || getScroll();\n\n    var checkForInterruption = _interruptionTracker(getScroll, initialValue, function () {\n      tween.kill();\n      getTween.tween = 0;\n    });\n\n    change2 = change1 && change2 || 0; // if change1 is 0, we set that to the difference and ignore change2. Otherwise, there would be a compound effect.\n\n    change1 = change1 || scrollTo - initialValue;\n    tween && tween.kill();\n    vars[prop] = scrollTo;\n    vars.inherit = false;\n    vars.modifiers = modifiers;\n\n    modifiers[prop] = function () {\n      return checkForInterruption(initialValue + change1 * tween.ratio + change2 * tween.ratio * tween.ratio);\n    };\n\n    vars.onUpdate = function () {\n      _scrollers.cache++;\n      getTween.tween && _updateAll(); // if it was interrupted/killed, like in a context.revert(), don't force an updateAll()\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\n  getScroll.wheelHandler = function () {\n    return getTween.tween && getTween.tween.kill() && (getTween.tween = 0);\n  };\n\n  _addListener(scroller, \"wheel\", getScroll.wheelHandler); // 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\n  ScrollTrigger.isTouch && _addListener(scroller, \"touchmove\", getScroll.wheelHandler);\n  return getTween;\n};\n\nexport var ScrollTrigger = /*#__PURE__*/function () {\n  function ScrollTrigger(vars, animation) {\n    _coreInitted || ScrollTrigger.register(gsap) || console.warn(\"Please gsap.registerPlugin(ScrollTrigger)\");\n\n    _context(this);\n\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(true, true); // 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 _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        pinSpacer = _vars.pinSpacer,\n        containerAnimation = _vars.containerAnimation,\n        fastScrollEnd = _vars.fastScrollEnd,\n        preventOverlaps = _vars.preventOverlaps,\n        direction = vars.horizontal || vars.containerAnimation && vars.horizontal !== false ? _horizontal : _vertical,\n        isToggle = !scrub && scrub !== 0,\n        scroller = _getTarget(vars.scroller || _win),\n        scrollerCache = gsap.core.getCache(scroller),\n        isViewport = _isViewport(scroller),\n        useFixedPosition = (\"pinType\" in vars ? vars.pinType : _getProxyProp(scroller, \"pinType\") || isViewport && \"fixed\") === \"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        lastSnap = 0,\n        lastRefresh = 0,\n        prevProgress = 0,\n        scrollFunc = _getScrollFunc(scroller, direction),\n        tweenTo,\n        pinCache,\n        snapFunc,\n        scroll1,\n        scroll2,\n        start,\n        end,\n        markerStart,\n        markerEnd,\n        markerStartTrigger,\n        markerEndTrigger,\n        markerVars,\n        executingOnRefresh,\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        pinMoves,\n        markerEndSetter,\n        cs,\n        snap1,\n        snap2,\n        scrubTween,\n        scrubSmooth,\n        snapDurClamp,\n        snapDelayedCall,\n        prevScroll,\n        prevAnimProgress,\n        caMarkerSetter,\n        customRevertReturn; // for the sake of efficiency, _startClamp/_endClamp serve like a truthy value indicating that clamping was enabled on the start/end, and ALSO store the actual pre-clamped numeric value. We tap into that in ScrollSmoother for speed effects. So for example, if start=\"clamp(top bottom)\" results in a start of -100 naturally, it would get clamped to 0 but -100 would be stored in _startClamp.\n\n\n    self._startClamp = self._endClamp = false;\n    self._dir = direction;\n    anticipatePin *= 45;\n    self.scroller = scroller;\n    self.scroll = containerAnimation ? containerAnimation.time.bind(containerAnimation) : scrollFunc;\n    scroll1 = scrollFunc();\n    self.vars = vars;\n    animation = animation || vars.animation;\n\n    if (\"refreshPriority\" in vars) {\n      _sort = 1;\n      vars.refreshPriority === -9999 && (_primary = self); // used by ScrollSmoother\n    }\n\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    self.scrubDuration = function (value) {\n      scrubSmooth = _isNumber(value) && value;\n\n      if (!scrubSmooth) {\n        scrubTween && scrubTween.progress(1).kill();\n        scrubTween = 0;\n      } else {\n        scrubTween ? scrubTween.duration(value) : scrubTween = gsap.to(animation, {\n          ease: \"expo\",\n          totalProgress: \"+=0\",\n          inherit: false,\n          duration: scrubSmooth,\n          paused: true,\n          onComplete: function onComplete() {\n            return onScrubComplete && onScrubComplete(self);\n          }\n        });\n      }\n    };\n\n    if (animation) {\n      animation.vars.lazy = false;\n      animation._initted && !self.isReverted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.duration() && animation.render(0, true, true); // special case: if this ScrollTrigger gets re-initted, a from() tween with a stagger could get initted initially and then reverted on the re-init which means it'll need to get rendered again here to properly display things. Otherwise, See https://gsap.com/forums/topic/36777-scrollsmoother-splittext-nextjs/ and https://codepen.io/GreenSock/pen/eYPyPpd?editors=0010\n\n      self.animation = animation.pause();\n      animation.scrollTrigger = self;\n      self.scrubDuration(scrub);\n      snap1 = 0;\n      id || (id = animation.vars.id);\n    }\n\n    if (snap) {\n      // TODO: potential idea: use legitimate CSS scroll snapping by pushing invisible elements into the DOM that serve as snap positions, and toggle the document.scrollingElement.style.scrollSnapType onToggle. See https://codepen.io/GreenSock/pen/JjLrgWM for a quick proof of concept.\n      if (!_isObject(snap) || snap.push) {\n        snap = {\n          snapTo: snap\n        };\n      }\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      _scrollers.forEach(function (o) {\n        return _isFunction(o) && o.target === (isViewport ? _doc.scrollingElement || _docEl : scroller) && (o.smooth = false);\n      }); // note: set smooth to false on both the vertical and horizontal scroll getters/setters\n\n\n      snapFunc = _isFunction(snap.snapTo) ? snap.snapTo : snap.snapTo === \"labels\" ? _getClosestLabel(animation) : snap.snapTo === \"labelsDirectional\" ? _getLabelAtDirection(animation) : snap.directional !== false ? function (value, st) {\n        return _snapDirectional(snap.snapTo)(value, _getTime() - lastRefresh < 500 ? 0 : st.direction);\n      } : 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        var scroll = scrollFunc(),\n            refreshedRecently = _getTime() - lastRefresh < 500,\n            tween = tweenTo.tween;\n\n        if ((refreshedRecently || Math.abs(self.getVelocity()) < 10) && !tween && !_pointerIsDown && lastSnap !== scroll) {\n          var progress = (scroll - start) / change,\n              totalProgress = animation && !isToggle ? animation.totalProgress() : progress,\n              velocity = refreshedRecently ? 0 : (totalProgress - snap2) / (_getTime() - _time2) * 1000 || 0,\n              change1 = gsap.utils.clamp(-progress, 1 - progress, _abs(velocity / 2) * velocity / 0.185),\n              naturalEnd = progress + (snap.inertia === false ? 0 : change1),\n              endValue,\n              endScroll,\n              _snap = snap,\n              onStart = _snap.onStart,\n              _onInterrupt = _snap.onInterrupt,\n              _onComplete = _snap.onComplete;\n          endValue = snapFunc(naturalEnd, self);\n          _isNumber(endValue) || (endValue = naturalEnd); // in case the function didn't return a number, fall back to using the naturalEnd\n\n          endScroll = Math.round(start + endValue * change);\n\n          if (scroll <= end && scroll >= start && endScroll !== scroll) {\n            if (tween && !tween._initted && tween.data <= _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            if (snap.inertia === false) {\n              change1 = endValue - progress;\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: _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                self.update();\n                lastSnap = scrollFunc();\n\n                if (animation) {\n                  // the resolution of the scrollbar is limited, so we should correct the scrubbed animation's playhead at the end to match EXACTLY where it was supposed to snap\n                  scrubTween ? scrubTween.resetTo(\"totalProgress\", endValue, animation._tTime / animation._tDur) : animation.progress(endValue);\n                }\n\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 && lastSnap !== scroll) {\n          snapDelayedCall.restart(true);\n        }\n      }).pause();\n    }\n\n    id && (_ids[id] = self);\n    trigger = self.trigger = _getTarget(trigger || pin !== true && pin); // if a trigger has some kind of scroll-related effect applied that could contaminate the \"y\" or \"x\" position (like a ScrollSmoother effect), we needed a way to temporarily revert it, so we use the stRevert property of the gsCache. It can return another function that we'll call at the end so it can return to its normal state.\n\n    customRevertReturn = trigger && trigger._gsap && trigger._gsap.stRevert;\n    customRevertReturn && (customRevertReturn = customRevertReturn(self));\n    pin = pin === true ? trigger : _getTarget(pin);\n    _isString(toggleClass) && (toggleClass = {\n      targets: trigger,\n      className: toggleClass\n    });\n\n    if (pin) {\n      pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && pin.parentNode && pin.parentNode.style && _getComputedStyle(pin.parentNode).display === \"flex\" ? false : _padding); // if the parent is display: flex, don't apply pinSpacing by default. We should check that pin.parentNode is an element (not shadow dom window)\n\n      self.pin = pin;\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        if (pinSpacer) {\n          pinSpacer = _getTarget(pinSpacer);\n          pinSpacer && !pinSpacer.nodeType && (pinSpacer = pinSpacer.current || pinSpacer.nativeElement); // for React & Angular\n\n          pinCache.spacerIsNative = !!pinSpacer;\n          pinSpacer && (pinCache.spacerState = _getState(pinSpacer));\n        }\n\n        pinCache.spacer = spacer = pinSpacer || _doc.createElement(\"div\");\n        spacer.classList.add(\"pin-spacer\");\n        id && spacer.classList.add(\"pin-spacer-\" + id);\n        pinCache.pinState = pinOriginalState = _getState(pin);\n      } else {\n        pinOriginalState = pinCache.pinState;\n      }\n\n      vars.force3D !== false && gsap.set(pin, {\n        force3D: true\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\n      var content = _getTarget(_getProxyProp(scroller, \"content\") || scroller);\n\n      markerStart = this.markerStart = _createMarker(\"start\", id, content, direction, markerVars, offset, 0, containerAnimation);\n      markerEnd = this.markerEnd = _createMarker(\"end\", id, content, direction, markerVars, offset, 0, containerAnimation);\n      containerAnimation && (caMarkerSetter = gsap.quickSetter([markerStart, markerEnd], direction.a, _px));\n\n      if (!useFixedPosition && !(_proxies.length && _getProxyProp(scroller, \"fixedMarkers\") === true)) {\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    if (containerAnimation) {\n      var oldOnUpdate = containerAnimation.vars.onUpdate,\n          oldParams = containerAnimation.vars.onUpdateParams;\n      containerAnimation.eventCallback(\"onUpdate\", function () {\n        self.update(0, 0, 1);\n        oldOnUpdate && oldOnUpdate.apply(containerAnimation, oldParams || []);\n      });\n    }\n\n    self.previous = function () {\n      return _triggers[_triggers.indexOf(self) - 1];\n    };\n\n    self.next = function () {\n      return _triggers[_triggers.indexOf(self) + 1];\n    };\n\n    self.revert = function (revert, temp) {\n      if (!temp) {\n        return self.kill(true);\n      } // for compatibility with gsap.context() and gsap.matchMedia() which call revert()\n\n\n      var r = revert !== false || !self.enabled,\n          prevRefreshing = _refreshing;\n\n      if (r !== self.isReverted) {\n        if (r) {\n          prevScroll = Math.max(scrollFunc(), 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\n        if (r) {\n          _refreshing = self;\n          self.update(r); // make sure the pin is back in its original position so that all the measurements are correct. do this BEFORE swapping the pin out\n        }\n\n        if (pin && (!pinReparent || !self.isActive)) {\n          if (r) {\n            _swapPinOut(pin, spacer, pinOriginalState);\n          } else {\n            _swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState);\n          }\n        }\n\n        r || self.update(r); // when we're restoring, the update should run AFTER swapping the pin into its pin-spacer.\n\n        _refreshing = prevRefreshing; // restore. We set it to true during the update() so that things fire properly in there.\n\n        self.isReverted = r;\n      }\n    };\n\n    self.refresh = function (soft, force, position, pinOffset) {\n      // position is typically only defined if it's coming from setPositions() - it's a way to skip the normal parsing. pinOffset is also only from setPositions() and is mostly related to fancy stuff we need to do in ScrollSmoother with effects\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      !_refreshingAll && onRefreshInit && onRefreshInit(self);\n      _refreshing = self;\n\n      if (tweenTo.tween && !position) {\n        // we skip this if a position is passed in because typically that's from .setPositions() and it's best to allow in-progress snapping to continue.\n        tweenTo.tween.kill();\n        tweenTo.tween = 0;\n      }\n\n      scrubTween && scrubTween.pause();\n      invalidateOnRefresh && animation && animation.revert({\n        kill: false\n      }).invalidate();\n      self.isReverted || self.revert(true, true);\n      self._subPinOffset = false; // we'll set this to true in the sub-pins if we find any\n\n      var size = getScrollerSize(),\n          scrollerBounds = getScrollerOffsets(),\n          max = containerAnimation ? containerAnimation.duration() : _maxScroll(scroller, direction),\n          isFirstRefresh = change <= 0.01,\n          offset = 0,\n          otherPinOffset = pinOffset || 0,\n          parsedEnd = _isObject(position) ? position.end : vars.end,\n          parsedEndTrigger = vars.endTrigger || trigger,\n          parsedStart = _isObject(position) ? position.start : vars.start || (vars.start === 0 || !trigger ? 0 : pin ? \"0 0\" : \"0 100%\"),\n          pinnedContainer = self.pinnedContainer = vars.pinnedContainer && _getTarget(vars.pinnedContainer, self),\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          revertedPins,\n          forcedOverflow,\n          markerStartOffset,\n          markerEndOffset;\n\n      if (markers && _isObject(position)) {\n        // if we alter the start/end positions with .setPositions(), it generally feeds in absolute NUMBERS which don't convey information about where to line up the markers, so to keep it intuitive, we record how far the trigger positions shift after applying the new numbers and then offset by that much in the opposite direction. We do the same to the associated trigger markers too of course.\n        markerStartOffset = gsap.getProperty(markerStartTrigger, direction.p);\n        markerEndOffset = gsap.getProperty(markerEndTrigger, direction.p);\n      }\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 = self); // 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\n        if (curPin && (curPin === trigger || curPin === pin || curPin === pinnedContainer) && !curTrigger.isReverted) {\n          revertedPins || (revertedPins = []);\n          revertedPins.unshift(curTrigger); // we'll revert from first to last to make sure things reach their end state properly\n\n          curTrigger.revert(true, true);\n        }\n\n        if (curTrigger !== _triggers[i]) {\n          // in case it got removed.\n          triggerIndex--;\n          i--;\n        }\n      }\n\n      _isFunction(parsedStart) && (parsedStart = parsedStart(self));\n      parsedStart = _parseClamp(parsedStart, \"start\", self);\n      start = _parsePosition(parsedStart, trigger, size, direction, scrollFunc(), markerStart, markerStartTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._startClamp && \"_startClamp\") || (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 : (containerAnimation ? gsap.utils.mapRange(0, containerAnimation.duration(), containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, start) : 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      parsedEnd = _parseClamp(parsedEnd, \"end\", self);\n      end = Math.max(start, _parsePosition(parsedEnd || (parsedEndTrigger ? \"100% 0\" : max), parsedEndTrigger, size, direction, scrollFunc() + offset, markerEnd, markerEndTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._endClamp && \"_endClamp\")) || -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 && !containerAnimation && curTrigger.end > 0) {\n          cs = curTrigger.end - (self._startClamp ? Math.max(0, curTrigger.start) : curTrigger.start);\n\n          if ((curPin === trigger && curTrigger.start - curTrigger._pinPush < start || curPin === pinnedContainer) && isNaN(parsedStart)) {\n            // numeric start values shouldn't be offset at all - treat them as absolute\n            offset += cs * (1 - curTrigger.progress);\n          }\n\n          curPin === pin && (otherPinOffset += cs);\n        }\n      }\n\n      start += offset;\n      end += offset;\n      self._startClamp && (self._startClamp += offset);\n\n      if (self._endClamp && !_refreshingAll) {\n        self._endClamp = end || -0.001;\n        end = Math.min(end, _maxScroll(scroller, direction));\n      }\n\n      change = end - start || (start -= 0.01) && 0.001;\n\n      if (isFirstRefresh) {\n        // on the very first refresh(), the prevProgress couldn't have been accurate yet because the start/end were never calculated, so we set it here. Before 3.11.5, it could lead to an inaccurate scroll position restoration with snapping.\n        prevProgress = gsap.utils.clamp(0, 1, gsap.utils.normalize(start, end, prevScroll));\n      }\n\n      self._pinPush = otherPinOffset;\n\n      if (markerStart && offset) {\n        // offset the markers if necessary\n        cs = {};\n        cs[direction.a] = \"+=\" + offset;\n        pinnedContainer && (cs[direction.p] = \"-=\" + scrollFunc());\n        gsap.set([markerStart, markerEnd], cs);\n      }\n\n      if (pin && !(_clampingMax && self.end >= _maxScroll(scroller, direction))) {\n        cs = _getComputedStyle(pin);\n        isVertical = direction === _vertical;\n        scroll = scrollFunc(); // recalculate because the triggers can affect the scroll\n\n        pinStart = parseFloat(pinGetter(direction.a)) + otherPinOffset;\n\n        if (!max && end > 1) {\n          // 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://gsap.com/forums/topic/25182-scrolltrigger-width-of-page-increase-where-markers-are-set-to-false/\n          forcedOverflow = (isViewport ? _doc.scrollingElement || _docEl : scroller).style;\n          forcedOverflow = {\n            style: forcedOverflow,\n            value: forcedOverflow[\"overflow\" + direction.a.toUpperCase()]\n          };\n\n          if (isViewport && _getComputedStyle(_body)[\"overflow\" + direction.a.toUpperCase()] !== \"scroll\") {\n            // avoid an extra scrollbar if BOTH <html> and <body> have overflow set to \"scroll\"\n            forcedOverflow.style[\"overflow\" + direction.a.toUpperCase()] = \"scroll\";\n          }\n        }\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\n          if (i) {\n            spacerState.push(direction.d, i + _px); // for box-sizing: border-box (must include padding).\n\n            spacer.style.flexBasis !== \"auto\" && (spacer.style.flexBasis = i + _px);\n          }\n\n          _setState(spacerState);\n\n          if (pinnedContainer) {\n            // in ScrollTrigger.refresh(), we need to re-evaluate the pinContainer's size because this pinSpacing may stretch it out, but we can't just add the exact distance because depending on layout, it may not push things down or it may only do so partially.\n            _triggers.forEach(function (t) {\n              if (t.pin === pinnedContainer && t.vars.pinSpacing !== false) {\n                t._subPinOffset = true;\n              }\n            });\n          }\n\n          useFixedPosition && scrollFunc(prevScroll);\n        } else {\n          i = _getSize(pin, direction);\n          i && spacer.style.flexBasis !== \"auto\" && (spacer.style.flexBasis = i + _px);\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          _refreshingAll && scrollFunc(0);\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.render(animation.duration(), true, true);\n          pinChange = pinGetter(direction.a) - pinStart + change + otherPinOffset;\n          pinMoves = Math.abs(change - pinChange) > 1;\n          useFixedPosition && pinMoves && 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.render(0, true, true);\n          initted || animation.invalidate(true);\n          animation.parent || animation.totalTime(animation.totalTime()); // if, for example, a toggleAction called play() and then refresh() happens and when we render(1) above, it would cause the animation to complete and get removed from its parent, so this makes sure it gets put back in.\n\n          _suppressOverwrites(0);\n        } else {\n          pinChange = change;\n        }\n\n        forcedOverflow && (forcedOverflow.value ? forcedOverflow.style[\"overflow\" + direction.a.toUpperCase()] = forcedOverflow.value : forcedOverflow.style.removeProperty(\"overflow-\" + direction.a));\n      } else if (trigger && scrollFunc() && !containerAnimation) {\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      revertedPins && revertedPins.forEach(function (t) {\n        return t.revert(false, true);\n      });\n      self.start = start;\n      self.end = end;\n      scroll1 = scroll2 = _refreshingAll ? prevScroll : scrollFunc(); // reset velocity\n\n      if (!containerAnimation && !_refreshingAll) {\n        scroll1 < prevScroll && scrollFunc(prevScroll);\n        self.scroll.rec = 0;\n      }\n\n      self.revert(false, true);\n      lastRefresh = _getTime();\n\n      if (snapDelayedCall) {\n        lastSnap = -1; // just so snapping gets re-enabled, clear out any recorded last value\n        // self.isActive && scrollFunc(start + change * prevProgress); // previously this line was here to ensure that when snapping kicks in, it's from the previous progress but in some cases that's not desirable, like an all-page ScrollTrigger when new content gets added to the page, that'd totally change the progress.\n\n        snapDelayedCall.restart(true);\n      }\n\n      _refreshing = 0;\n      animation && isToggle && (animation._initted || prevAnimProgress) && animation.progress() !== prevAnimProgress && animation.progress(prevAnimProgress || 0, 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 (isFirstRefresh || prevProgress !== self.progress || containerAnimation || invalidateOnRefresh) {\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        animation && !isToggle && animation.totalProgress(containerAnimation && start < -0.001 && !prevProgress ? gsap.utils.normalize(start, end, 0) : prevProgress, true); // to avoid issues where animation callbacks like onStart aren't triggered.\n\n        self.progress = isFirstRefresh || (scroll1 - start) / change === prevProgress ? 0 : prevProgress;\n      }\n\n      pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange));\n      scrubTween && scrubTween.invalidate();\n\n      if (!isNaN(markerStartOffset)) {\n        // numbers were passed in for the position which are absolute, so instead of just putting the markers at the very bottom of the viewport, we figure out how far they shifted down (it's safe to assume they were originally positioned in closer relation to the trigger element with values like \"top\", \"center\", a percentage or whatever, so we offset that much in the opposite direction to basically revert them to the relative position thy were at previously.\n        markerStartOffset -= gsap.getProperty(markerStartTrigger, direction.p);\n        markerEndOffset -= gsap.getProperty(markerEndTrigger, direction.p);\n\n        _shiftMarker(markerStartTrigger, direction, markerStartOffset);\n\n        _shiftMarker(markerStart, direction, markerStartOffset - (pinOffset || 0));\n\n        _shiftMarker(markerEndTrigger, direction, markerEndOffset);\n\n        _shiftMarker(markerEnd, direction, markerEndOffset - (pinOffset || 0));\n      }\n\n      isFirstRefresh && !_refreshingAll && self.update(); // edge case - when you reload a page when it's already scrolled down, some browsers fire a \"scroll\" event before DOMContentLoaded, triggering an updateAll(). If we don't update the self.progress as part of refresh(), then when it happens next, it may record prevProgress as 0 when it really shouldn't, potentially causing a callback in an animation to fire again.\n\n      if (onRefresh && !_refreshingAll && !executingOnRefresh) {\n        // when refreshing all, we do extra work to correct pinnedContainer sizes and ensure things don't exceed the maxScroll, so we should do all the refreshes at the end after all that work so that the start/end values are corrected.\n        executingOnRefresh = true;\n        onRefresh(self);\n        executingOnRefresh = false;\n      }\n    };\n\n    self.getVelocity = function () {\n      return (scrollFunc() - scroll2) / (_getTime() - _time2) * 1000 || 0;\n    };\n\n    self.endAnimation = function () {\n      _endAnimation(self.callbackAnimation);\n\n      if (animation) {\n        scrubTween ? scrubTween.progress(1) : !animation.paused() ? _endAnimation(animation, animation.reversed()) : isToggle || _endAnimation(animation, self.direction < 0, 1);\n      }\n    };\n\n    self.labelToScroll = function (label) {\n      return animation && animation.labels && (start || self.refresh() || start) + animation.labels[label] / animation.duration() * change || 0;\n    };\n\n    self.getTrailing = function (name) {\n      var i = _triggers.indexOf(self),\n          a = self.direction > 0 ? _triggers.slice(0, i).reverse() : _triggers.slice(i + 1);\n\n      return (_isString(name) ? a.filter(function (t) {\n        return t.vars.preventOverlaps === name;\n      }) : a).filter(function (t) {\n        return self.direction > 0 ? t.end <= start : t.start >= end;\n      });\n    };\n\n    self.update = function (reset, recordVelocity, forceFake) {\n      if (containerAnimation && !forceFake && !reset) {\n        return;\n      }\n\n      var scroll = _refreshingAll === true ? prevScroll : 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          isAtMax,\n          isTakingAction;\n\n      if (recordVelocity) {\n        scroll2 = scroll1;\n        scroll1 = containerAnimation ? scrollFunc() : 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      if (anticipatePin && pin && !_refreshing && !_startup && _lastScrollTime) {\n        if (!clipped && start < scroll + (scroll - scroll2) / (_getTime() - _time2) * anticipatePin) {\n          clipped = 0.0001;\n        } else if (clipped === 1 && end > scroll + (scroll - scroll2) / (_getTime() - _time2) * anticipatePin) {\n          clipped = 0.9999;\n        }\n      }\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 (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            isTakingAction = animation && (action === \"complete\" || action === \"reset\" || action in animation);\n          }\n        }\n\n        preventOverlaps && (toggled || isTakingAction) && (isTakingAction || scrub || !animation) && (_isFunction(preventOverlaps) ? preventOverlaps(self) : self.getTrailing(preventOverlaps).forEach(function (t) {\n          return t.endAnimation();\n        }));\n\n        if (!isToggle) {\n          if (scrubTween && !_refreshing && !_startup) {\n            scrubTween._dp._time - scrubTween._start !== scrubTween._time && scrubTween.render(scrubTween._dp._time - scrubTween._start); // if there's a scrub on both the container animation and this one (or a ScrollSmoother), the update order would cause this one not to have rendered yet, so it wouldn't make any progress before we .restart() it heading toward the new progress so it'd appear stuck thus we force a render here.\n\n            if (scrubTween.resetTo) {\n              scrubTween.resetTo(\"totalProgress\", clipped, animation._tTime / animation._tDur);\n            } else {\n              // legacy support (courtesy), before 3.10.0\n              scrubTween.vars.totalProgress = clipped;\n              scrubTween.invalidate().restart();\n            }\n          } else if (animation) {\n            animation.totalProgress(clipped, !!(_refreshing && (lastRefresh || reset)));\n          }\n        }\n\n        if (pin) {\n          reset && pinSpacing && (spacer.style[pinSpacing + direction.os2] = spacingStart);\n\n          if (!useFixedPosition) {\n            pinSetter(_round(pinStart + pinChange * clipped));\n          } else if (stateChanged) {\n            isAtMax = !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 || isAtMax)) {\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 || isAtMax ? pinActiveState : pinState);\n\n            pinMoves && clipped < 1 && isActive || pinSetter(pinStart + (clipped === 1 && !isAtMax ? 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          if (isToggle) {\n            if (isTakingAction) {\n              if (action === \"complete\") {\n                animation.pause().totalProgress(1);\n              } else if (action === \"reset\") {\n                animation.restart(true).pause();\n              } else if (action === \"restart\") {\n                animation.restart(true);\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 && _callback(self, onToggle);\n            callbacks[toggleState] && _callback(self, callbacks[toggleState]);\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] && _callback(self, callbacks[toggleState]);\n            }\n          }\n\n          if (fastScrollEnd && !isActive && Math.abs(self.getVelocity()) > (_isNumber(fastScrollEnd) ? fastScrollEnd : 2500)) {\n            _endAnimation(self.callbackAnimation);\n\n            scrubTween ? scrubTween.progress(1) : _endAnimation(animation, action === \"reverse\" ? 1 : !clipped, 1);\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        var n = containerAnimation ? scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0) : scroll;\n        markerStartSetter(n + (markerStartTrigger._isFlipped ? 1 : 0));\n        markerEndSetter(n);\n      }\n\n      caMarkerSetter && caMarkerSetter(-scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0));\n    };\n\n    self.enable = function (reset, refresh) {\n      if (!self.enabled) {\n        self.enabled = true;\n\n        _addListener(scroller, \"resize\", _onResize);\n\n        isViewport || _addListener(scroller, \"scroll\", _onScroll);\n        onRefreshInit && _addListener(ScrollTrigger, \"refreshInit\", onRefreshInit);\n\n        if (reset !== false) {\n          self.progress = prevProgress = 0;\n          scroll1 = scroll2 = lastSnap = scrollFunc();\n        }\n\n        refresh !== false && self.refresh();\n      }\n    };\n\n    self.getTween = function (snap) {\n      return snap && tweenTo ? tweenTo.tween : scrubTween;\n    };\n\n    self.setPositions = function (newStart, newEnd, keepClamp, pinOffset) {\n      // doesn't persist after refresh()! Intended to be a way to override values that were set during refresh(), like you could set it in onRefresh()\n      if (containerAnimation) {\n        // convert ratios into scroll positions. Remember, start/end values on ScrollTriggers that have a containerAnimation refer to the time (in seconds), NOT scroll positions.\n        var st = containerAnimation.scrollTrigger,\n            duration = containerAnimation.duration(),\n            _change = st.end - st.start;\n\n        newStart = st.start + _change * newStart / duration;\n        newEnd = st.start + _change * newEnd / duration;\n      }\n\n      self.refresh(false, false, {\n        start: _keepClamp(newStart, keepClamp && !!self._startClamp),\n        end: _keepClamp(newEnd, keepClamp && !!self._endClamp)\n      }, pinOffset);\n      self.update();\n    };\n\n    self.adjustPinSpacing = function (amount) {\n      if (spacerState && amount) {\n        var i = spacerState.indexOf(direction.d) + 1;\n        spacerState[i] = parseFloat(spacerState[i]) + amount + _px;\n        spacerState[1] = parseFloat(spacerState[1]) + amount + _px;\n\n        _setState(spacerState);\n      }\n    };\n\n    self.disable = function (reset, allowAnimation) {\n      if (self.enabled) {\n        reset !== false && self.revert(true, true);\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          isViewport || _removeListener(scroller, \"scroll\", _onScroll);\n        }\n      }\n    };\n\n    self.kill = function (revert, allowAnimation) {\n      self.disable(revert, allowAnimation);\n      scrubTween && !allowAnimation && scrubTween.kill();\n      id && delete _ids[id];\n\n      var i = _triggers.indexOf(self);\n\n      i >= 0 && _triggers.splice(i, 1);\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      // if no other ScrollTrigger instances of the same scroller are found, wipe out any recorded scroll position. Otherwise, in a single page application, for example, it could maintain scroll position when it really shouldn't.\n\n      i = 0;\n\n      _triggers.forEach(function (t) {\n        return t.scroller === self.scroller && (i = 1);\n      });\n\n      i || _refreshingAll || (self.scroll.rec = 0);\n\n      if (animation) {\n        animation.scrollTrigger = null;\n        revert && animation.revert({\n          kill: false\n        });\n        allowAnimation || animation.kill();\n      }\n\n      markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {\n        return m.parentNode && m.parentNode.removeChild(m);\n      });\n      _primary === self && (_primary = 0);\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      vars.onKill && vars.onKill(self);\n    };\n\n    _triggers.push(self);\n\n    self.enable(false, false);\n    customRevertReturn && customRevertReturn(self);\n\n    if (animation && animation.add && !change) {\n      // 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. If \"change\" is defined, we know it must be re-enabling, thus we can refresh() right away.\n      var updateFunc = self.update; // some browsers may fire a scroll event BEFORE a tick elapses and/or the DOMContentLoaded fires. So there's a chance update() will be called BEFORE a refresh() has happened on a Timeline-attached ScrollTrigger which means the start/end won't be calculated yet. We don't want to add conditional logic inside the update() method (like check to see if end is defined and if not, force a refresh()) because that's a function that gets hit a LOT (performance). So we swap out the real update() method for this one that'll re-attach it the first time it gets called and of course forces a refresh().\n\n      self.update = function () {\n        self.update = updateFunc;\n        start || end || self.refresh();\n      };\n\n      gsap.delayedCall(0.01, self.update);\n      change = 0.01;\n      start = end = 0;\n    } else {\n      self.refresh();\n    }\n\n    pin && _queueRefreshAll(); // pinning could affect the positions of other things, so make sure we queue a full refresh()\n  };\n\n  ScrollTrigger.register = function register(core) {\n    if (!_coreInitted) {\n      gsap = core || _getGSAP();\n      _windowExists() && window.document && ScrollTrigger.enable();\n      _coreInitted = _enabled;\n    }\n\n    return _coreInitted;\n  };\n\n  ScrollTrigger.defaults = function defaults(config) {\n    if (config) {\n      for (var p in config) {\n        _defaults[p] = config[p];\n      }\n    }\n\n    return _defaults;\n  };\n\n  ScrollTrigger.disable = function disable(reset, kill) {\n    _enabled = 0;\n\n    _triggers.forEach(function (trigger) {\n      return trigger[kill ? \"kill\" : \"disable\"](reset);\n    });\n\n    _removeListener(_win, \"wheel\", _onScroll);\n\n    _removeListener(_doc, \"scroll\", _onScroll);\n\n    clearInterval(_syncInterval);\n\n    _removeListener(_doc, \"touchcancel\", _passThrough);\n\n    _removeListener(_body, \"touchstart\", _passThrough);\n\n    _multiListener(_removeListener, _doc, \"pointerdown,touchstart,mousedown\", _pointerDownHandler);\n\n    _multiListener(_removeListener, _doc, \"pointerup,touchend,mouseup\", _pointerUpHandler);\n\n    _resizeDelay.kill();\n\n    _iterateAutoRefresh(_removeListener);\n\n    for (var i = 0; i < _scrollers.length; i += 3) {\n      _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 1]);\n\n      _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 2]);\n    }\n  };\n\n  ScrollTrigger.enable = function enable() {\n    _win = window;\n    _doc = document;\n    _docEl = _doc.documentElement;\n    _body = _doc.body;\n\n    if (gsap) {\n      _toArray = gsap.utils.toArray;\n      _clamp = gsap.utils.clamp;\n      _context = gsap.core.context || _passThrough;\n      _suppressOverwrites = gsap.core.suppressOverwrites || _passThrough;\n      _scrollRestoration = _win.history.scrollRestoration || \"auto\";\n      _lastScroll = _win.pageYOffset;\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        _enabled = 1;\n        _div100vh = document.createElement(\"div\"); // to solve mobile browser address bar show/hide resizing, we shouldn't rely on window.innerHeight. Instead, use a <div> with its height set to 100vh and measure that since that's what the scrolling is based on anyway and it's not affected by address bar showing/hiding.\n\n        _div100vh.style.height = \"100vh\";\n        _div100vh.style.position = \"absolute\";\n\n        _refresh100vh();\n\n        _rafBugFix();\n\n        Observer.register(gsap); // isTouch is 0 if no touch, 1 if ONLY touch, and 2 if it can accommodate touch but also other types like mouse/pointer.\n\n        ScrollTrigger.isTouch = Observer.isTouch;\n        _fixIOSBug = Observer.isTouch && /(iPad|iPhone|iPod|Mac)/g.test(navigator.userAgent); // since 2017, iOS has had a bug that causes event.clientX/Y to be inaccurate when a scroll occurs, thus we must alternate ignoring every other touchmove event to work around it. See https://bugs.webkit.org/show_bug.cgi?id=181954 and https://codepen.io/GreenSock/pen/ExbrPNa/087cef197dc35445a0951e8935c41503\n\n        _ignoreMobileResize = Observer.isTouch === 1;\n\n        _addListener(_win, \"wheel\", _onScroll); // mostly for 3rd party smooth scrolling libraries.\n\n\n        _root = [_win, _doc, _docEl, _body];\n\n        if (gsap.matchMedia) {\n          ScrollTrigger.matchMedia = function (vars) {\n            var mm = gsap.matchMedia(),\n                p;\n\n            for (p in vars) {\n              mm.add(p, vars[p]);\n            }\n\n            return mm;\n          };\n\n          gsap.addEventListener(\"matchMediaInit\", function () {\n            return _revertAll();\n          });\n          gsap.addEventListener(\"matchMediaRevert\", function () {\n            return _revertRecorded();\n          });\n          gsap.addEventListener(\"matchMedia\", function () {\n            _refreshAll(0, 1);\n\n            _dispatch(\"matchMedia\");\n          });\n          gsap.matchMedia(\"(orientation: portrait)\", function () {\n            // when orientation changes, we should take new base measurements for the ignoreMobileResize feature.\n            _setBaseDimensions();\n\n            return _setBaseDimensions;\n          });\n        } else {\n          console.warn(\"Requires GSAP 3.11.0 or later\");\n        }\n\n        _setBaseDimensions();\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.borderTopStyle,\n            AnimationProto = gsap.core.Animation.prototype,\n            bounds,\n            i;\n        AnimationProto.revert || Object.defineProperty(AnimationProto, \"revert\", {\n          value: function value() {\n            return this.time(-0.01, true);\n          }\n        }); // only for backwards compatibility (Animation.revert() was added after 3.10.4)\n\n        bodyStyle.borderTopStyle = \"solid\"; // 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.borderTopStyle = border : bodyStyle.removeProperty(\"border-top-style\"); // TODO: (?) maybe move to leveraging the velocity mechanism in Observer and skip intervals.\n\n        _syncInterval = setInterval(_sync, 250);\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://gsap.com/forums/topic/21450-draggable-in-iframe-on-mobile-is-buggy/\n\n\n        _multiListener(_addListener, _doc, \"pointerdown,touchstart,mousedown\", _pointerDownHandler);\n\n        _multiListener(_addListener, _doc, \"pointerup,touchend,mouseup\", _pointerUpHandler);\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\", _refreshAll, _win, \"resize\", _onResize];\n\n        _iterateAutoRefresh(_addListener);\n\n        _triggers.forEach(function (trigger) {\n          return trigger.enable(0, 1);\n        });\n\n        for (i = 0; i < _scrollers.length; i += 3) {\n          _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 1]);\n\n          _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 2]);\n        }\n      }\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    \"ignoreMobileResize\" in vars && (_ignoreMobileResize = ScrollTrigger.isTouch === 1 && vars.ignoreMobileResize);\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 = _getTarget(target),\n        i = _scrollers.indexOf(t),\n        isViewport = _isViewport(t);\n\n    if (~i) {\n      _scrollers.splice(i, isViewport ? 6 : 2);\n    }\n\n    if (vars) {\n      isViewport ? _proxies.unshift(_win, vars, _body, vars, _docEl, vars) : _proxies.unshift(t, vars);\n    }\n  };\n\n  ScrollTrigger.clearMatchMedia = function clearMatchMedia(query) {\n    _triggers.forEach(function (t) {\n      return t._ctx && t._ctx.query === query && t._ctx.kill(true, true);\n    });\n  };\n\n  ScrollTrigger.isInViewport = function isInViewport(element, ratio, horizontal) {\n    var bounds = (_isString(element) ? _getTarget(element) : element).getBoundingClientRect(),\n        offset = bounds[horizontal ? _width : _height] * ratio || 0;\n    return horizontal ? bounds.right - offset > 0 && bounds.left + offset < _win.innerWidth : bounds.bottom - offset > 0 && bounds.top + offset < _win.innerHeight;\n  };\n\n  ScrollTrigger.positionInViewport = function positionInViewport(element, referencePoint, horizontal) {\n    _isString(element) && (element = _getTarget(element));\n    var bounds = element.getBoundingClientRect(),\n        size = bounds[horizontal ? _width : _height],\n        offset = referencePoint == null ? size / 2 : referencePoint in _keywords ? _keywords[referencePoint] * size : ~referencePoint.indexOf(\"%\") ? parseFloat(referencePoint) * size / 100 : parseFloat(referencePoint) || 0;\n    return horizontal ? (bounds.left + offset) / _win.innerWidth : (bounds.top + offset) / _win.innerHeight;\n  };\n\n  ScrollTrigger.killAll = function killAll(allowListeners) {\n    _triggers.slice(0).forEach(function (t) {\n      return t.vars.id !== \"ScrollSmoother\" && t.kill();\n    });\n\n    if (allowListeners !== true) {\n      var listeners = _listeners.killAll || [];\n      _listeners = {};\n      listeners.forEach(function (f) {\n        return f();\n      });\n    }\n  };\n\n  return ScrollTrigger;\n}();\nScrollTrigger.version = \"3.12.5\";\n\nScrollTrigger.saveStyles = function (targets) {\n  return targets ? _toArray(targets).forEach(function (target) {\n    // saved styles are recorded in a consecutive alternating Array, like [element, cssText, transform attribute, cache, matchMedia, ...]\n    if (target && target.style) {\n      var i = _savedStyles.indexOf(target);\n\n      i >= 0 && _savedStyles.splice(i, 5);\n\n      _savedStyles.push(target, target.style.cssText, target.getBBox && target.getAttribute(\"transform\"), gsap.core.getCache(target), _context());\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() : (_coreInitted || ScrollTrigger.register()) && _refreshAll(true);\n};\n\nScrollTrigger.update = function (force) {\n  return ++_scrollers.cache && _updateAll(force === true ? 2 : 0);\n};\n\nScrollTrigger.clearScrollMemory = _clearScrollMemory;\n\nScrollTrigger.maxScroll = function (element, horizontal) {\n  return _maxScroll(element, horizontal ? _horizontal : _vertical);\n};\n\nScrollTrigger.getScrollFunc = function (element, horizontal) {\n  return _getScrollFunc(_getTarget(element), horizontal ? _horizontal : _vertical);\n};\n\nScrollTrigger.getById = function (id) {\n  return _ids[id];\n};\n\nScrollTrigger.getAll = function () {\n  return _triggers.filter(function (t) {\n    return t.vars.id !== \"ScrollSmoother\";\n  });\n}; // it's common for people to ScrollTrigger.getAll(t => t.kill()) on page routes, for example, and we don't want it to ruin smooth scrolling by killing the main ScrollSmoother one.\n\n\nScrollTrigger.isScrolling = function () {\n  return !!_lastScrollTime;\n};\n\nScrollTrigger.snapDirectional = _snapDirectional;\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}; // to reduce file size. clamps the scroll and also returns a duration multiplier so that if the scroll gets chopped shorter, the duration gets curtailed as well (otherwise if you're very close to the top of the page, for example, and swipe up really fast, it'll suddenly slow down and take a long time to reach the top).\n\n\nvar _clampScrollAndGetDurationMultiplier = function _clampScrollAndGetDurationMultiplier(scrollFunc, current, end, max) {\n  current > max ? scrollFunc(max) : current < 0 && scrollFunc(0);\n  return end > max ? (max - current) / (end - current) : end < 0 ? current / (current - end) : 1;\n},\n    _allowNativePanning = function _allowNativePanning(target, direction) {\n  if (direction === true) {\n    target.style.removeProperty(\"touch-action\");\n  } else {\n    target.style.touchAction = direction === true ? \"auto\" : direction ? \"pan-\" + direction + (Observer.isTouch ? \" pinch-zoom\" : \"\") : \"none\"; // note: Firefox doesn't support it pinch-zoom properly, at least in addition to a pan-x or pan-y.\n  }\n\n  target === _docEl && _allowNativePanning(_body, direction);\n},\n    _overflow = {\n  auto: 1,\n  scroll: 1\n},\n    _nestedScroll = function _nestedScroll(_ref5) {\n  var event = _ref5.event,\n      target = _ref5.target,\n      axis = _ref5.axis;\n\n  var node = (event.changedTouches ? event.changedTouches[0] : event).target,\n      cache = node._gsap || gsap.core.getCache(node),\n      time = _getTime(),\n      cs;\n\n  if (!cache._isScrollT || time - cache._isScrollT > 2000) {\n    // cache for 2 seconds to improve performance.\n    while (node && node !== _body && (node.scrollHeight <= node.clientHeight && node.scrollWidth <= node.clientWidth || !(_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]))) {\n      node = node.parentNode;\n    }\n\n    cache._isScroll = node && node !== target && !_isViewport(node) && (_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]);\n    cache._isScrollT = time;\n  }\n\n  if (cache._isScroll || axis === \"x\") {\n    event.stopPropagation();\n    event._gsapAllow = true;\n  }\n},\n    // capture events on scrollable elements INSIDE the <body> and allow those by calling stopPropagation() when we find a scrollable ancestor\n_inputObserver = function _inputObserver(target, type, inputs, nested) {\n  return Observer.create({\n    target: target,\n    capture: true,\n    debounce: false,\n    lockAxis: true,\n    type: type,\n    onWheel: nested = nested && _nestedScroll,\n    onPress: nested,\n    onDrag: nested,\n    onScroll: nested,\n    onEnable: function onEnable() {\n      return inputs && _addListener(_doc, Observer.eventTypes[0], _captureInputs, false, true);\n    },\n    onDisable: function onDisable() {\n      return _removeListener(_doc, Observer.eventTypes[0], _captureInputs, true);\n    }\n  });\n},\n    _inputExp = /(input|label|select|textarea)/i,\n    _inputIsFocused,\n    _captureInputs = function _captureInputs(e) {\n  var isInput = _inputExp.test(e.target.tagName);\n\n  if (isInput || _inputIsFocused) {\n    e._gsapAllow = true;\n    _inputIsFocused = isInput;\n  }\n},\n    _getScrollNormalizer = function _getScrollNormalizer(vars) {\n  _isObject(vars) || (vars = {});\n  vars.preventDefault = vars.isNormalizer = vars.allowClicks = true;\n  vars.type || (vars.type = \"wheel,touch\");\n  vars.debounce = !!vars.debounce;\n  vars.id = vars.id || \"normalizer\";\n\n  var _vars2 = vars,\n      normalizeScrollX = _vars2.normalizeScrollX,\n      momentum = _vars2.momentum,\n      allowNestedScroll = _vars2.allowNestedScroll,\n      onRelease = _vars2.onRelease,\n      self,\n      maxY,\n      target = _getTarget(vars.target) || _docEl,\n      smoother = gsap.core.globals().ScrollSmoother,\n      smootherInstance = smoother && smoother.get(),\n      content = _fixIOSBug && (vars.content && _getTarget(vars.content) || smootherInstance && vars.content !== false && !smootherInstance.smooth() && smootherInstance.content()),\n      scrollFuncY = _getScrollFunc(target, _vertical),\n      scrollFuncX = _getScrollFunc(target, _horizontal),\n      scale = 1,\n      initialScale = (Observer.isTouch && _win.visualViewport ? _win.visualViewport.scale * _win.visualViewport.width : _win.outerWidth) / _win.innerWidth,\n      wheelRefresh = 0,\n      resolveMomentumDuration = _isFunction(momentum) ? function () {\n    return momentum(self);\n  } : function () {\n    return momentum || 2.8;\n  },\n      lastRefreshID,\n      skipTouchMove,\n      inputObserver = _inputObserver(target, vars.type, true, allowNestedScroll),\n      resumeTouchMove = function resumeTouchMove() {\n    return skipTouchMove = false;\n  },\n      scrollClampX = _passThrough,\n      scrollClampY = _passThrough,\n      updateClamps = function updateClamps() {\n    maxY = _maxScroll(target, _vertical);\n    scrollClampY = _clamp(_fixIOSBug ? 1 : 0, maxY);\n    normalizeScrollX && (scrollClampX = _clamp(0, _maxScroll(target, _horizontal)));\n    lastRefreshID = _refreshID;\n  },\n      removeContentOffset = function removeContentOffset() {\n    content._gsap.y = _round(parseFloat(content._gsap.y) + scrollFuncY.offset) + \"px\";\n    content.style.transform = \"matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, \" + parseFloat(content._gsap.y) + \", 0, 1)\";\n    scrollFuncY.offset = scrollFuncY.cacheID = 0;\n  },\n      ignoreDrag = function ignoreDrag() {\n    if (skipTouchMove) {\n      requestAnimationFrame(resumeTouchMove);\n\n      var offset = _round(self.deltaY / 2),\n          scroll = scrollClampY(scrollFuncY.v - offset);\n\n      if (content && scroll !== scrollFuncY.v + scrollFuncY.offset) {\n        scrollFuncY.offset = scroll - scrollFuncY.v;\n\n        var y = _round((parseFloat(content && content._gsap.y) || 0) - scrollFuncY.offset);\n\n        content.style.transform = \"matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, \" + y + \", 0, 1)\";\n        content._gsap.y = y + \"px\";\n        scrollFuncY.cacheID = _scrollers.cache;\n\n        _updateAll();\n      }\n\n      return true;\n    }\n\n    scrollFuncY.offset && removeContentOffset();\n    skipTouchMove = true;\n  },\n      tween,\n      startScrollX,\n      startScrollY,\n      onStopDelayedCall,\n      onResize = function onResize() {\n    // if the window resizes, like on an iPhone which Apple FORCES the address bar to show/hide even if we event.preventDefault(), it may be scrolling too far now that the address bar is showing, so we must dynamically adjust the momentum tween.\n    updateClamps();\n\n    if (tween.isActive() && tween.vars.scrollY > maxY) {\n      scrollFuncY() > maxY ? tween.progress(1) && scrollFuncY(maxY) : tween.resetTo(\"scrollY\", maxY);\n    }\n  };\n\n  content && gsap.set(content, {\n    y: \"+=0\"\n  }); // to ensure there's a cache (element._gsap)\n\n  vars.ignoreCheck = function (e) {\n    return _fixIOSBug && e.type === \"touchmove\" && ignoreDrag(e) || scale > 1.05 && e.type !== \"touchstart\" || self.isGesturing || e.touches && e.touches.length > 1;\n  };\n\n  vars.onPress = function () {\n    skipTouchMove = false;\n    var prevScale = scale;\n    scale = _round((_win.visualViewport && _win.visualViewport.scale || 1) / initialScale);\n    tween.pause();\n    prevScale !== scale && _allowNativePanning(target, scale > 1.01 ? true : normalizeScrollX ? false : \"x\");\n    startScrollX = scrollFuncX();\n    startScrollY = scrollFuncY();\n    updateClamps();\n    lastRefreshID = _refreshID;\n  };\n\n  vars.onRelease = vars.onGestureStart = function (self, wasDragging) {\n    scrollFuncY.offset && removeContentOffset();\n\n    if (!wasDragging) {\n      onStopDelayedCall.restart(true);\n    } else {\n      _scrollers.cache++; // make sure we're pulling the non-cached value\n      // alternate algorithm: durX = Math.min(6, Math.abs(self.velocityX / 800)),\tdur = Math.max(durX, Math.min(6, Math.abs(self.velocityY / 800))); dur = dur * (0.4 + (1 - _power4In(dur / 6)) * 0.6)) * (momentumSpeed || 1)\n\n      var dur = resolveMomentumDuration(),\n          currentScroll,\n          endScroll;\n\n      if (normalizeScrollX) {\n        currentScroll = scrollFuncX();\n        endScroll = currentScroll + dur * 0.05 * -self.velocityX / 0.227; // the constant .227 is from power4(0.05). velocity is inverted because scrolling goes in the opposite direction.\n\n        dur *= _clampScrollAndGetDurationMultiplier(scrollFuncX, currentScroll, endScroll, _maxScroll(target, _horizontal));\n        tween.vars.scrollX = scrollClampX(endScroll);\n      }\n\n      currentScroll = scrollFuncY();\n      endScroll = currentScroll + dur * 0.05 * -self.velocityY / 0.227; // the constant .227 is from power4(0.05)\n\n      dur *= _clampScrollAndGetDurationMultiplier(scrollFuncY, currentScroll, endScroll, _maxScroll(target, _vertical));\n      tween.vars.scrollY = scrollClampY(endScroll);\n      tween.invalidate().duration(dur).play(0.01);\n\n      if (_fixIOSBug && tween.vars.scrollY >= maxY || currentScroll >= maxY - 1) {\n        // iOS bug: it'll show the address bar but NOT fire the window \"resize\" event until the animation is done but we must protect against overshoot so we leverage an onUpdate to do so.\n        gsap.to({}, {\n          onUpdate: onResize,\n          duration: dur\n        });\n      }\n    }\n\n    onRelease && onRelease(self);\n  };\n\n  vars.onWheel = function () {\n    tween._ts && tween.pause();\n\n    if (_getTime() - wheelRefresh > 1000) {\n      // after 1 second, refresh the clamps otherwise that'll only happen when ScrollTrigger.refresh() is called or for touch-scrolling.\n      lastRefreshID = 0;\n      wheelRefresh = _getTime();\n    }\n  };\n\n  vars.onChange = function (self, dx, dy, xArray, yArray) {\n    _refreshID !== lastRefreshID && updateClamps();\n    dx && normalizeScrollX && scrollFuncX(scrollClampX(xArray[2] === dx ? startScrollX + (self.startX - self.x) : scrollFuncX() + dx - xArray[1])); // for more precision, we track pointer/touch movement from the start, otherwise it'll drift.\n\n    if (dy) {\n      scrollFuncY.offset && removeContentOffset();\n      var isTouch = yArray[2] === dy,\n          y = isTouch ? startScrollY + self.startY - self.y : scrollFuncY() + dy - yArray[1],\n          yClamped = scrollClampY(y);\n      isTouch && y !== yClamped && (startScrollY += yClamped - y);\n      scrollFuncY(yClamped);\n    }\n\n    (dy || dx) && _updateAll();\n  };\n\n  vars.onEnable = function () {\n    _allowNativePanning(target, normalizeScrollX ? false : \"x\");\n\n    ScrollTrigger.addEventListener(\"refresh\", onResize);\n\n    _addListener(_win, \"resize\", onResize);\n\n    if (scrollFuncY.smooth) {\n      scrollFuncY.target.style.scrollBehavior = \"auto\";\n      scrollFuncY.smooth = scrollFuncX.smooth = false;\n    }\n\n    inputObserver.enable();\n  };\n\n  vars.onDisable = function () {\n    _allowNativePanning(target, true);\n\n    _removeListener(_win, \"resize\", onResize);\n\n    ScrollTrigger.removeEventListener(\"refresh\", onResize);\n    inputObserver.kill();\n  };\n\n  vars.lockAxis = vars.lockAxis !== false;\n  self = new Observer(vars);\n  self.iOS = _fixIOSBug; // used in the Observer getCachedScroll() function to work around an iOS bug that wreaks havoc with TouchEvent.clientY if we allow scroll to go all the way back to 0.\n\n  _fixIOSBug && !scrollFuncY() && scrollFuncY(1); // iOS bug causes event.clientY values to freak out (wildly inaccurate) if the scroll position is exactly 0.\n\n  _fixIOSBug && gsap.ticker.add(_passThrough); // prevent the ticker from sleeping\n\n  onStopDelayedCall = self._dc;\n  tween = gsap.to(self, {\n    ease: \"power4\",\n    paused: true,\n    inherit: false,\n    scrollX: normalizeScrollX ? \"+=0.1\" : \"+=0\",\n    scrollY: \"+=0.1\",\n    modifiers: {\n      scrollY: _interruptionTracker(scrollFuncY, scrollFuncY(), function () {\n        return tween.pause();\n      })\n    },\n    onUpdate: _updateAll,\n    onComplete: onStopDelayedCall.vars.onComplete\n  }); // we need the modifier to sense if the scroll position is altered outside of the momentum tween (like with a scrollTo tween) so we can pause() it to prevent conflicts.\n\n  return self;\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\nScrollTrigger.observe = function (vars) {\n  return new Observer(vars);\n};\n\nScrollTrigger.normalizeScroll = function (vars) {\n  if (typeof vars === \"undefined\") {\n    return _normalizer;\n  }\n\n  if (vars === true && _normalizer) {\n    return _normalizer.enable();\n  }\n\n  if (vars === false) {\n    _normalizer && _normalizer.kill();\n    _normalizer = vars;\n    return;\n  }\n\n  var normalizer = vars instanceof Observer ? vars : _getScrollNormalizer(vars);\n  _normalizer && _normalizer.target === normalizer.target && _normalizer.kill();\n  _isViewport(normalizer.target) && (_normalizer = normalizer);\n  return normalizer;\n};\n\nScrollTrigger.core = {\n  // smaller file size way to leverage in ScrollSmoother and Observer\n  _getVelocityProp: _getVelocityProp,\n  _inputObserver: _inputObserver,\n  _scrollers: _scrollers,\n  _proxies: _proxies,\n  bridge: {\n    // when normalizeScroll sets the scroll position (ss = setScroll)\n    ss: function ss() {\n      _lastScrollTime || _dispatch(\"scrollStart\");\n      _lastScrollTime = _getTime();\n    },\n    // a way to get the _refreshing value in Observer\n    ref: function ref() {\n      return _refreshing;\n    }\n  }\n};\n_getGSAP() && gsap.registerPlugin(ScrollTrigger);\nexport { ScrollTrigger as default };","import React from \"react\";\r\nimport \"../styles/home.css\";\r\n\r\n// Define the types for the props\r\ninterface ContactCardProps {\r\n  picture: string;\r\n  name: string;\r\n  email: string;\r\n  label: string;\r\n  region: string;\r\n  phone: string;\r\n  headline: string;\r\n}\r\n\r\nconst ContactCard: React.FC<ContactCardProps> = ({\r\n  picture,\r\n  name,\r\n  email,\r\n  label,\r\n  region,\r\n  phone,\r\n  headline,\r\n}) => {\r\n  return (\r\n    <div className=\"bg-white rounded-r-xl sm:rounded-xl overflow-hidden flex flex-col lg:flex-row p-8\">\r\n      <div className=\"z-10 overflow-hidden flex-none lg:-m-8 lg:mr-8 lg:w-56 w-auto h-auto\">\r\n        <img\r\n          src={picture}\r\n          className=\"object-cover bg-gray-100 w-full h-full\"\r\n          alt={`${name}'s picture`}\r\n        />\r\n      </div>\r\n      <div className=\"description max-w-xs flex flex-col justify-between\">\r\n        <section>\r\n          <h2 className=\"pb-1 pt-2\">{name}</h2>\r\n          <p>{label}</p>\r\n          <p>\r\n            <i className=\"bi bi-envelope pr-1\"></i>\r\n            <a href={`mailto:${email}`}>{email}</a>\r\n          </p>\r\n          <p>\r\n            <i className=\"bi bi-phone pr-1\"></i>\r\n            {phone}\r\n          </p>\r\n          <p>\r\n            <i className=\"bi bi-geo-alt pr-1\"></i>\r\n            {region}\r\n          </p>\r\n          <p\r\n            className=\"font-mono text-sm my-3\"\r\n            dangerouslySetInnerHTML={{ __html: headline }}\r\n          />\r\n        </section>\r\n        <section>\r\n          <a href=\"/cv\">Click here for my full CV.</a>\r\n        </section>\r\n      </div>\r\n    </div>\r\n  );\r\n};\r\n\r\nexport default ContactCard;\r\n","import gsap from \"gsap\";\r\nimport React, { useEffect } from \"react\";\r\nimport ContactCard from \"./ContactCard\";\r\n\r\n// Define types for the props\r\ninterface HeroProps {\r\n  [key: string]: any; // This allows for any additional props that ContactCard might need\r\n}\r\n\r\nconst Hero: React.FC<HeroProps> = (props) => {\r\n  useEffect(() => {\r\n    const tl = gsap.timeline({ defaults: { ease: \"power1.out\" } });\r\n\r\n    tl.to(\"#logo\", { y: \"0%\", opacity: 1, duration: 1, stagger: 0.25 });\r\n    tl.to(\"#slider\", { y: \"-100%\", duration: 1.5, delay: 0.5 });\r\n    tl.to(\"#intro\", { y: \"-100%\", duration: 1 }, \"-=1\");\r\n\r\n    tl.to(\".card\", { x: \"0%\", duration: 0.5 });\r\n    tl.to(\".welcome\", { y: \"0%\", opacity: 1, duration: 1 });\r\n  }, []);\r\n\r\n  return (\r\n    <div className=\"bg-[url('/5651978.png')] bg-cover bg-center h-screen flex panel\">\r\n      <div\r\n        className=\"bg-white flex-grow absolute z-50 top-0 left-0 w-full h-full grid place-content-center overflow-hidden intro\"\r\n        id=\"intro\"\r\n      >\r\n        <img\r\n          src=\"./logo.png\"\r\n          alt=\"Logo\"\r\n          id=\"logo\"\r\n          className=\"my-logo translate-y-full opacity-0 w-16 animate-spin\"\r\n        />\r\n      </div>\r\n      <div\r\n        className=\"bg-yellow fixed top-0 left-0 w-full h-100 slider\"\r\n        id=\"slider\"\r\n      ></div>\r\n      <div className=\"relative justify-center m-auto flex flex-wrap lg:flex-nowrap hero container lg:justify-between\">\r\n        <ContactCard {...props} />\r\n        <div className=\"welcome lg:flex flex-col my-auto hidden flex-1 text-current text-right text-4xl opacity-0 translate-y-full font-serif\">\r\n          <p className=\"welcome-text mb-0 shad\">Welcome</p>\r\n          <p className=\"welcome-text mb-0\">to my</p>\r\n          <p className=\"welcome-text mb-0\">Portfolio</p>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  );\r\n};\r\n\r\nexport default Hero;\r\n","import React, { useEffect, useState } from \"react\";\r\n\r\n// Define types for the Project props\r\ninterface ProjectProps {\r\n  title?: string;\r\n  link?: string;\r\n  date?: string;\r\n  image_url?: string;\r\n  background?: string;\r\n  background_color?: string;\r\n  description: string;\r\n  panelClass?: string;\r\n  stack?: string;\r\n}\r\n\r\nconst Project: React.FC<ProjectProps> = ({\r\n  title,\r\n  link,\r\n  date,\r\n  image_url,\r\n  background,\r\n  background_color,\r\n  description,\r\n  panelClass,\r\n  stack,\r\n}) => {\r\n  const [toggle, setToggle] = useState<boolean>(false);\r\n  const [backgroundImage, setBackgroundImage] = useState<string | undefined>(background);\r\n\r\n  useEffect(() => {\r\n    const screenWidth = window.innerWidth || document.documentElement.clientWidth;\r\n    setToggle(screenWidth < 900);\r\n\r\n    const fetchRandomImage = async () => {\r\n      let images: { src: { large: string } }[] = [];\r\n      try {\r\n        const response = await fetch(\r\n          \"https://api.pexels.com/v1/search?query=abstract&orientation=landscape&size=large&per_page=25\",\r\n          {\r\n            headers: { 'Authorization': `0Yj9fnhb8D5ZsYMFnnOUwgw35xD4rviKaYpJJEwg6kkRzu0m60QViXAZ` }\r\n          }\r\n        );\r\n        const json = await response.json();\r\n        images = json['photos'];\r\n        if (images.length > 0) {\r\n          setBackgroundImage(images[Math.floor(Math.random() * images.length)]['src']['large']);\r\n        }\r\n      } catch (error) {\r\n        console.error(\"Failed to fetch images:\", error);\r\n      }\r\n    };\r\n\r\n    if (!background) {\r\n      fetchRandomImage();\r\n    }\r\n  }, [background]);\r\n\r\n  const techs = stack?.split(\",\").map((tech, i) => (\r\n    <p\r\n      className=\"rounded-full py-1 px-3 text-white bg-gray-700 text-xs mr-2\"\r\n      key={i}\r\n    >\r\n      {tech}\r\n    </p>\r\n  ));\r\n\r\n  const img = backgroundImage ? (\r\n    <img\r\n      src={backgroundImage}\r\n      className=\"absolute z-0 max-w-none object-cover bg-gray-100 w-full h-full left-0 top-0 mb-0\"\r\n      alt=\"\"\r\n    />\r\n  ) : (\r\n    <div className=\"absolute z-0 max-w-none object-cover bg-gray-100 w-full h-full left-0 top-0 mb-0\"></div>\r\n  );\r\n\r\n  return (\r\n    <article\r\n      className={`flex-grow lg:w-1/2 w-full flex flex-col justify-center align-middle min-h-screen ${panelClass || ''}`}\r\n    >\r\n      <div\r\n        className=\"relative overflow-hidden flex-none h-100\"\r\n        role=\"button\"\r\n        tabIndex={0}\r\n        onMouseEnter={() => setToggle(true)}\r\n        onMouseLeave={() => setToggle(false)}\r\n      >\r\n        {background_color ? null : img}\r\n        <div\r\n          className=\"relative flex flex-col lg:justify-center h-full items-center z-10\"\r\n          style={{ backgroundColor: background_color ? `#${background_color}` : undefined }}\r\n        >\r\n          <header className=\"flex justify-center h-28 mt-40 lg:mt-0\">\r\n            {image_url && (\r\n              <img\r\n                src={image_url}\r\n                className=\"max-h-20 min-h-20 w-40\"\r\n                alt=\"\"\r\n              />\r\n            )}\r\n          </header>\r\n        </div>\r\n\r\n        <div\r\n          className={`absolute transform bg-gray-50 bg-opacity-75 bg z-20 w-full ${\r\n            toggle\r\n              ? \"lg:-translate-y-full translate-y-[-175%]\"\r\n              : \"translate-y-0\"\r\n          } transition-transform`}\r\n        >\r\n          <div className=\"flex flex-col justify-center p-4\">\r\n            <h2 className=\"font-bold text-center py-2 text-md\">\r\n              {title || link}\r\n            </h2>\r\n            <section className=\"overflow-ellipsis overflow-hidden\">\r\n              <div\r\n                dangerouslySetInnerHTML={{\r\n                  __html: description,\r\n                }}\r\n              />\r\n              <div className=\"flex mt-2\">\r\n                <p className=\"rounded-full py-1 px-3 bg-gray-700 text-white mr-2 p-2 text-xs\">\r\n                  HTML+CSS\r\n                </p>\r\n                {techs}\r\n              </div>\r\n            </section>\r\n            <div className=\"flex justify-between items-center\">\r\n              {date && <p>{date}</p>}\r\n              {link && <a href={link}>Visit site</a>}\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </article>\r\n  );\r\n};\r\n\r\nexport default Project;\r\n","import _ from \"lodash\";\r\nimport React, { useEffect, useRef, useState } from \"react\";\r\nimport Project from \"./Project\";\r\n\r\n// Define types for the Project node\r\ninterface ProjectNode {\r\n  id: string;\r\n  html: string;\r\n  frontmatter: {\r\n    title?: string;\r\n    link?: string;\r\n    date?: string;\r\n    image_url?: string;\r\n    background?: string;\r\n    background_color?: string;\r\n    description: string;\r\n    panelClass?: string;\r\n    stack?: string;\r\n  };\r\n}\r\n\r\n// Define types for the Projects props\r\ninterface ProjectsProps {\r\n  projects: { node: ProjectNode }[];\r\n}\r\n\r\nconst Projects: React.FC<ProjectsProps> = ({ projects }) => {\r\n  const [sticky, setSticky] = useState<string>(\"Present\");\r\n  const [, setOffset] = useState<number>(0);\r\n  const ref = useRef<HTMLDivElement>(null);\r\n\r\n  console.log('projects', projects);\r\n\r\n  const updateValue = _.debounce((val: number) => {\r\n    let found = false;\r\n    document.querySelectorAll(\"article\").forEach((article) => {\r\n      if (isElementInViewport(article) && !found) {\r\n        setSticky(article.getAttribute(\"year\") || \"Present\");\r\n        found = true;\r\n      }\r\n    });\r\n    setOffset(val);\r\n  }, 100);\r\n\r\n  const handleScroll = (event: Event) => {\r\n    updateValue(window.pageYOffset);\r\n  };\r\n\r\n  useEffect(() => {\r\n    window.addEventListener(\"scroll\", handleScroll);\r\n\r\n    return () => {\r\n      window.removeEventListener(\"scroll\", handleScroll);\r\n    };\r\n    // eslint-disable-next-line react-hooks/exhaustive-deps\r\n  }, []);\r\n\r\n  function isElementInViewport(el: HTMLElement): boolean {\r\n    const rect = el.getBoundingClientRect();\r\n    const windowHeight =\r\n      window.innerHeight || document.documentElement.clientHeight;\r\n    const windowWidth =\r\n      window.innerWidth || document.documentElement.clientWidth;\r\n\r\n    const vertInView = rect.top <= windowHeight && rect.top + rect.height >= 0;\r\n    const horInView = rect.left <= windowWidth && rect.left + rect.width >= 0;\r\n\r\n    return vertInView && horInView;\r\n  }\r\n\r\n  const scrollTop = () => {\r\n    window.scrollTo({ top: 0, behavior: \"smooth\" });\r\n  };\r\n\r\n  return (\r\n    <div ref={ref} className=\"projects grid grid-cols-1 bg-projects relative\">\r\n      <h1 className=\"text-3xl py-8 pl-4 sticky top-0 left-0 text-black z-20\">\r\n        Projects - {sticky}\r\n      </h1>\r\n\r\n      <div className=\"flex flex-wrap lg:px-28\">\r\n        {projects.map((project, i) => (\r\n          <Project\r\n            panelClass={`${i % 2 === 0 ? \"\" : \"panel lg:pl-2\"}`}\r\n            key={project.node.id}\r\n            {...project.node.frontmatter}\r\n            description={project.node.html}\r\n          />\r\n        ))}\r\n      </div>\r\n\r\n      <button\r\n        onClick={scrollTop}\r\n        className=\"text-3xl py-8 pl-4 sticky bottom-0 right-0 cursor-pointer group animate-bounce text-black flex\"\r\n      >\r\n        <i className=\"bi bi-arrow-up ml-auto mr-8 group-hover:text-red-400\"> </i>\r\n      </button>\r\n    </div>\r\n  );\r\n};\r\n\r\nexport default Projects;\r\n","import React, { useState } from \"react\";\r\n\r\n// Define types for the ChallengeCard props\r\ninterface ChallengeCardProps {\r\n  title?: string;\r\n  link?: string;\r\n  image_url?: string;\r\n  background?: string;\r\n  background_color?: string;\r\n  description: string;\r\n  panelClass?: string;\r\n  stack?: string;\r\n}\r\n\r\nconst ChallengeCard: React.FC<ChallengeCardProps> = ({\r\n  title,\r\n  link,\r\n  image_url,\r\n  background,\r\n  background_color,\r\n  description,\r\n  panelClass,\r\n  stack,\r\n}) => {\r\n  const [toggle, setToggle] = useState(false);\r\n\r\n  const techs = stack?.split(\",\").map((tech, i) => (\r\n    <p\r\n      className=\"rounded-full py-1 px-3 text-white bg-gray-700 text-xs mr-2\"\r\n      key={i}\r\n    >\r\n      {tech}\r\n    </p>\r\n  ));\r\n\r\n  const img = background ? (\r\n    <img\r\n      src={background}\r\n      className=\"absolute z-0 max-w-none object-cover bg-gray-100 w-full h-full left-0 top-0 mb-0\"\r\n      alt=\"\"\r\n    />\r\n  ) : (\r\n    <div className=\"absolute z-0 max-w-none object-cover bg-gray-100 w-full h-full left-0 top-0 mb-0\" />\r\n  );\r\n\r\n  return (\r\n    <div\r\n      className={`flex-grow lg:w-1/3 w-full flex flex-col justify-center align-middle min-h-screen ${panelClass || ''}`}\r\n    >\r\n      <div\r\n        className=\"relative overflow-hidden flex-none h-100\"\r\n        role=\"button\"\r\n        tabIndex={0}\r\n        onMouseEnter={() => setToggle(true)}\r\n        onMouseLeave={() => setToggle(false)}\r\n      >\r\n        {background_color ? null : img}\r\n        <div\r\n          className=\"relative flex flex-col lg:justify-center h-full items-center z-10\"\r\n          style={{ backgroundColor: background_color ? `#${background_color}` : undefined }}\r\n        >\r\n          <header className=\"flex justify-center h-28 mt-40 lg:mt-0\">\r\n            {image_url && (\r\n              <img\r\n                src={image_url}\r\n                className=\"max-h-20 min-h-20 w-40\"\r\n                alt=\"\"\r\n              />\r\n            )}\r\n          </header>\r\n        </div>\r\n\r\n        <div\r\n          className={`absolute transform bg-gray-50 bg-opacity-75 bg z-20 w-full ${\r\n            toggle\r\n              ? \"lg:-translate-y-full translate-y-[-175%]\"\r\n              : \"lg:-translate-y-full translate-y-[-175%]\"\r\n          } transition-transform`}\r\n        >\r\n          <div className=\"flex flex-col justify-center p-4\">\r\n            <h2 className=\"font-bold text-center py-2 text-md\">\r\n              {title || link}\r\n            </h2>\r\n            <section className=\"overflow-ellipsis overflow-hidden\">\r\n              <div\r\n                dangerouslySetInnerHTML={{\r\n                  __html: description,\r\n                }}\r\n              />\r\n              <div className=\"flex flex-wrap space-y-2 mt-2\">\r\n                <p className=\"rounded-full py-1 px-3 bg-gray-700 text-white mr-2 p-2 text-xs\">\r\n                  HTML+CSS\r\n                </p>\r\n                {techs}\r\n              </div>\r\n            </section>\r\n            <div className=\"flex justify-between items-center\">\r\n              {link && <a href={link}>Visit site</a>}\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  );\r\n};\r\n\r\nexport default ChallengeCard;\r\n","import React from \"react\";\r\nimport ChallengeCard from \"./ChallengeCard\";\r\n\r\n// Define the structure of frontmatter data for challenges\r\ninterface ChallengeFrontmatter {\r\n  title: string;\r\n  date: string;\r\n  slug: string;\r\n  excerpt: string;\r\n  image_url?: string;\r\n  background?: string;\r\n  background_color?: string;\r\n  class?: string;\r\n  link?: string;\r\n  stack?: string;\r\n  disabled?: boolean;\r\n}\r\n\r\n// Define the structure of a challenge node\r\ninterface ChallengeNode {\r\n  id: string;\r\n  html: string;\r\n  frontmatter: ChallengeFrontmatter;\r\n}\r\n\r\n// Define the type for the challenges prop\r\ninterface ChallengeProps {\r\n  challenges: {\r\n    node: ChallengeNode;\r\n  }[];\r\n}\r\n\r\nconst Challenge: React.FC<ChallengeProps> = ({ challenges }) => {\r\n  const scrollTop = () => {\r\n    window.scrollTo({ top: 0, behavior: \"smooth\" });\r\n  };\r\n\r\n  return (\r\n    <div className=\"grid grid-cols-1 bg-sides relative challenges\">\r\n      <h1 className=\"text-3xl py-8 pl-4 sticky top-0 left-0 text-black z-20\">\r\n        Challenges\r\n      </h1>\r\n\r\n      <div className=\"flex flex-wrap lg:px-28\">\r\n        {challenges.map((challenge, i) => (\r\n          <ChallengeCard\r\n            panelClass={`${i % 2 === 0 ? \"\" : \"panel lg:pl-2 lg:pr-2\"}`}\r\n            key={challenge.node.id}\r\n            {...challenge.node.frontmatter}\r\n            description={challenge.node.html}\r\n          />\r\n        ))}\r\n      </div>\r\n\r\n      <button\r\n        onClick={scrollTop}\r\n        className=\"text-3xl py-8 pl-4 sticky bottom-0 right-0 cursor-pointer group animate-bounce text-black flex\"\r\n      >\r\n        <i className=\"bi bi-arrow-up ml-auto mr-8 group-hover:text-red-400\">\r\n          {\" \"}\r\n        </i>\r\n      </button>\r\n    </div>\r\n  );\r\n};\r\n\r\nexport default Challenge;\r\n","import { graphql, PageProps } from \"gatsby\";\nimport gsap from \"gsap\";\nimport { ScrollTrigger } from \"gsap/ScrollTrigger\";\nimport React, { useEffect, useState } from \"react\";\nimport Hero from \"../components/Hero\";\nimport Projects from \"../components/Projects\";\nimport Layout from \"../layouts\";\nimport \"../styles/styles.css\";\nimport Challenge from \"../components/Challenge\";\n\n// Register GSAP plugin only in the browser\nif (typeof window !== `undefined`) {\n  gsap.registerPlugin(ScrollTrigger);\n  gsap.core.globals(\"ScrollTrigger\", ScrollTrigger);\n}\n\n// Define the types for the GraphQL query results\ninterface MarkdownRemarkNode {\n  id: string;\n  html: string;\n  fileAbsolutePath: string;\n  frontmatter: {\n    title: string;\n    date: string;\n    slug: string;\n    excerpt: string;\n    image_url?: string;\n    background?: string;\n    background_color?: string;\n    class?: string;\n    link?: string;\n    stack?: string;\n    disabled?: boolean;\n  };\n}\n\ninterface DataProps {\n  allMarkdownRemark: {\n    edges: {\n      node: MarkdownRemarkNode;\n    }[];\n  };\n  basic: {\n    value: {\n      profiles: {\n        network: string;\n        username: string;\n        url: string;\n      }[];\n      email: string;\n      headline: string;\n      label: string;\n      name: string;\n      phone: string;\n      picture: string;\n      region: string;\n      summary: string;\n      username: string;\n      website: string;\n      yearsOfExperience: number;\n    };\n  };\n}\n\n// Define the component props\ntype HomeProps = PageProps<{\n  site: {\n    siteMetadata: {\n      intro_image: string;\n    };\n  };\n  basic: {\n    value: {\n      profiles: {\n        network: string;\n        username: string;\n        url: string;\n      }[];\n      email: string;\n      headline: string;\n      label: string;\n      name: string;\n      phone: string;\n      picture: string;\n      region: string;\n      summary: string;\n      username: string;\n      website: string;\n      yearsOfExperience: number;\n    };\n  };\n  allMarkdownRemark: {\n    edges: {\n      node: MarkdownRemarkNode;\n    }[];\n  };\n}>;\n\nconst Home: React.FC<HomeProps> = ({ data }) => {\n  const [theme] = useState<string>(\"day\");\n\n  useEffect(() => {\n    document.documentElement.style.setProperty(\n      \"--background-color\",\n      `var(--${theme}-background-color)`\n    );\n    document.documentElement.style.setProperty(\n      \"--theme-accent-color\",\n      `var(--${theme}-accent-color)`\n    );\n    document.documentElement.style.setProperty(\n      \"--gradient\",\n      `var(--${theme}-gradient)`\n    );\n    document.documentElement.style.setProperty(\n      \"--text-color\",\n      `var(--${theme}-text-color)`\n    );\n  }, [theme]);\n\n  useEffect(() => {\n    gsap.registerPlugin(ScrollTrigger);\n\n    ScrollTrigger.defaults({\n      toggleActions: \"restart pause resume pause\",\n    });\n\n    gsap.to(\".challenges h1\", {\n      scrollTrigger: \".challenges\",\n      duration: 0.5,\n      opacity: 1,\n      y: \"0%\",\n    });\n\n    gsap.to(\".projects h1\", {\n      scrollTrigger: \".projects\",\n      duration: 0.5,\n      opacity: 1,\n      y: \"0%\",\n    });\n  }, []);\n\n  const projects = data.allMarkdownRemark.edges;\n\n  return (\n    <Layout data={data.basic.value}>\n      <Hero {...data.basic.value} />\n      <Challenge\n        challenges={projects.filter(\n          project => !project.node.frontmatter.disabled && project.node.fileAbsolutePath.includes('challenges')\n        )}\n      />\n      <Projects\n        projects={projects.filter(\n          project => !project.node.frontmatter.disabled && project.node.fileAbsolutePath.includes('clients')\n        )}\n      />\n    </Layout>\n  );\n};\n\nexport default Home;\n\nexport const query = graphql`\n  query MyQuery {\n    site {\n      siteMetadata {\n        intro_image\n      }\n    }\n    basic {\n      id\n      value {\n        profiles {\n          network\n          username\n          url\n        }\n        email\n        headline\n        label\n        name\n        phone\n        picture\n        region\n        summary\n        username\n        website\n        yearsOfExperience\n      }\n    }\n    allMarkdownRemark(\n      sort: [{ frontmatter: { date: DESC }}]\n    ) {\n      edges {\n        node {\n          id\n          html\n          fileAbsolutePath\n          frontmatter {\n            title\n            date(formatString: \"YYYY\")\n            image_url\n            background\n            background_color\n            class\n            link\n            stack\n            disabled\n          }\n          excerpt\n        }\n      }\n    }\n  }\n`;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nmodule.exports = baseTrim;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","var baseTrim = require('./_baseTrim'),\n    isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n"],"names":["_ref","children","data","React","className","Helmet","title","name","meta","content","summary","rel","href","_win","_doc","_docElement","_pluginInitted","_tempDiv","_recentSetterPlugin","_reverting","_supports3D","_transformProps","_RAD2DEG","Math","PI","_DEG2RAD","_atan2","atan2","_capsExp","_horizontalExp","_complexExp","_propertyAliases","autoAlpha","scale","alpha","_renderCSSProp","ratio","set","t","p","round","s","c","u","_renderPropWithEnd","e","_renderCSSPropWithBeginning","b","_renderRoundedCSSProp","value","_renderNonTweeningValue","_renderNonTweeningValueOnlyAtEnd","_setterCSSStyle","target","property","style","_setterCSSProp","setProperty","_setterTransform","_gsap","_setterScale","scaleX","scaleY","_setterScaleWithRender","cache","renderTransform","_setterTransformWithRender","_transformProp","_transformOriginProp","_saveStyle","isNotCSS","_this","this","tfm","transform","split","forEach","call","indexOf","a","_get","x","zOrigin","props","svg","svgo","getAttribute","push","_removeIndependentTransforms","translate","removeProperty","_revertStyle","i","length","substr","replace","toLowerCase","setAttribute","isStart","uncache","_getStyleSaver","properties","saver","revert","save","core","getCache","_createElement","type","ns","createElementNS","createElement","_getComputedProperty","skipPrefixFallback","cs","getComputedStyle","getPropertyValue","_checkPropPrefix","_prefixes","element","preferPrefix","charAt","toUpperCase","_initCore","window","document","documentElement","cssText","reverting","_getBBoxHack","swapIfPossible","bbox","ownerSVGElement","oldParent","parentNode","oldSibling","nextSibling","oldCSS","appendChild","display","getBBox","_gsapBBox","insertBefore","removeChild","_getAttributeFallbacks","attributesArray","hasAttribute","_getBBox","bounds","error","width","height","y","_isSVG","getCTM","_removeProperty","first2Chars","removeAttribute","_addNonTweeningPT","plugin","beginning","end","onlySetAtEnd","pt","_pt","_props","_nonConvertibleUnits","deg","rad","turn","_nonStandardLayouts","grid","flex","_convertToUnit","unit","px","parent","isSVG","curValue","parseFloat","curUnit","trim","horizontal","test","isRootSVG","tagName","measureProperty","amount","toPixels","toPercent","body","time","position","v","_parseTransform","origin","_firstTwoOnly","_specialProps","_tweenComplexCSSString","prop","start","result","startValues","startNum","color","startValue","endValue","endNum","chunk","endUnit","startUnit","index","matchIndex","match","exec","substring","lastIndex","units","_next","m","r","_keywordToPercent","top","bottom","left","right","center","_renderClearProps","tween","_time","_dur","clearTransforms","clearProps","pr","_identity2DMatrix","_rotationalProperties","_isNullTransform","_getComputedTransformMatrixAsArray","matrixString","map","_getMatrix","force2D","temp","addedToDOM","matrix","baseVal","consolidate","d","f","join","offsetParent","nextElementSibling","_applySVGOrigin","originIsAbsolute","smooth","matrixArray","pluginToAddPropTweensTo","determinant","xOriginOld","xOrigin","yOriginOld","yOrigin","xOffsetOld","xOffset","yOffsetOld","yOffset","tx","ty","originSplit","z","rotation","rotationX","rotationY","skewX","skewY","perspective","angle","cos","sin","a12","a22","t1","t2","t3","a13","a23","a33","a42","a43","a32","invertedScaleX","rotate","slice","sqrt","abs","forceCSS","xPercent","offsetWidth","yPercent","offsetHeight","transformPerspective","force3D","_renderSVGTransforms","_renderCSSTransforms","_renderNon3DTransforms","_addPxTranslate","_zeroDeg","_zeroPx","_endParenthesis","transforms","use3D","a11","a21","_ref2","tan","_addRotationalPropTween","direction","cap","isString","change","finalValue","_assign","source","_addRawTransformPTs","endCache","startCache","l","side","vars","arguments","init","positionAndScale","all","CSSPlugin","register","targetTest","nodeType","targets","specialProp","relative","isTransformRelated","transformPropTween","hasPriority","inlineProps","startAt","styles","add","visibility","parseTransform","smoothOrigin","dep","autoRound","render","get","aliases","getSetter","utils","checkPrefix","getStyleSaver","registerPlugin","gsapWithCSS","Tween","_defineProperties","descriptor","enumerable","configurable","writable","Object","defineProperty","key","gsap","_coreInitted","_docEl","_body","_isTouch","_pointerType","ScrollTrigger","_root","_normalizer","_eventTypes","_context","_getGSAP","_startup","_observers","_scrollers","_proxies","_getTime","Date","now","_bridge","_getProxyProp","_isViewport","el","_addListener","func","passive","capture","addEventListener","_removeListener","removeEventListener","_scrollLeft","_scrollTop","_onScroll","isPressed","_scrollCacheFunc","doNotCache","cachingFunc","history","scrollRestoration","isNormalizing","iOS","cacheID","offset","_horizontal","p2","os","os2","d2","sc","scrollTo","_vertical","pageXOffset","op","pageYOffset","_getTarget","self","_ctx","selector","toArray","config","nullTargetWarn","console","warn","_getScrollFunc","scrollingElement","prev","getProperty","_getVelocityProp","minTimeRefresh","useDelta","v1","v2","min","dropToZeroTime","max","update","force","reset","getVelocity","latestValue","tOld","vOld","_getEvent","preventDefault","_gsapAllow","changedTouches","_getAbsoluteMax","apply","_setScrollTrigger","scrollers","proxies","globals","bridge","clamp","context","Observer","isTouch","matchMedia","matches","navigator","maxTouchPoints","msMaxTouchPoints","eventTypes","setTimeout","Constructor","protoProps","staticProps","prototype","tolerance","dragMinimum","lineHeight","debounce","onStop","onStopDelay","ignore","wheelSpeed","event","onDragStart","onDragEnd","onDrag","onPress","onRelease","onRight","onLeft","onUp","onDown","onChangeX","onChangeY","onChange","onToggleX","onToggleY","onHover","onHoverEnd","onMove","ignoreCheck","isNormalizer","onGestureStart","onGestureEnd","onWheel","onEnable","onDisable","onClick","scrollSpeed","allowClicks","lockAxis","onLockAxis","id","onStopDelayedCall","dragged","moved","wheeled","locked","axis","prevDeltaX","prevDeltaY","scrollFuncX","scrollFuncY","scrollX","scrollY","limitToTouch","isViewport","ownerDoc","ownerDocument","deltaX","deltaY","onClickTime","clickCapture","_ignoreCheck","isPointerOrTouch","pointerType","dx","dy","changedX","changedY","onDelta","_vx","_vy","requestAnimationFrame","onTouchOrPointerDelta","_onDrag","clientX","clientY","isDragging","startX","startY","_onPress","button","pause","_onRelease","isTrackingDrag","isNaN","wasDragging","isDragNotClick","eventData","delayedCall","defaultPrevented","click","createEvent","syntheticEvent","initMouseEvent","screenX","screenY","dispatchEvent","isGesturing","restart","_onGestureStart","touches","_onGestureEnd","onScroll","_onWheel","multiplier","deltaMode","innerHeight","_onMove","_onHover","_onHoverEnd","_onClick","_dc","enable","isEnabled","disable","filter","o","kill","splice","version","create","getAll","getById","_resizeDelay","_toArray","_time2","_syncInterval","_refreshing","_pointerIsDown","_i","_prevWidth","_prevHeight","_autoRefresh","_sort","_suppressOverwrites","_ignoreResize","_ignoreMobileResize","_baseScreenHeight","_baseScreenWidth","_fixIOSBug","_scrollRestoration","_div100vh","_100vh","_isReverted","_clampingMax","_limitCallbacks","_rafID","_refreshingAll","_queueRefreshID","_primary","_time1","_lastScrollTime","_enabled","_parseClamp","_isString","_keepClamp","_rafBugFix","_pointerDownHandler","_pointerUpHandler","_passThrough","_round","_getViewportDimension","dimensionProperty","_getBoundsFunc","_winOffsets","innerWidth","_getBounds","_maxScroll","_iterateAutoRefresh","events","_isFunction","_isNumber","_isObject","_endAnimation","animation","reversed","progress","_callback","enabled","totalTime","callbackAnimation","_abs","_left","_right","_bottom","_width","_height","_Right","_Left","_Top","_Bottom","_padding","_margin","_Width","_Height","_px","_getComputedStyle","_setDefaults","obj","defaults","withoutTransforms","to","getBoundingClientRect","_getSize","_ref3","_getLabelRatioArray","timeline","labels","duration","_snapDirectional","snapIncrementOrArray","snap","Array","isArray","sort","threshold","snapped","_multiListener","types","callback","nonPassive","_wheelListener","scrollFunc","wheelHandler","_markerDefaults","startColor","endColor","indent","fontSize","fontWeight","_defaults","toggleActions","anticipatePin","_keywords","_offsetToPx","size","eqIndex","_createMarker","container","_ref4","matchWidthEl","containerAnimation","useFixedPosition","isScroller","css","_isStart","innerText","_offset","_positionMarker","marker","flipped","oppositeSide","_isFlipped","_triggers","_ids","_sync","_updateAll","clientWidth","_dispatch","_setBaseDimensions","_onResize","fullscreenElement","webkitFullscreenElement","_listeners","_emptyArray","_softRefresh","_refreshAll","_savedStyles","_revertRecorded","media","query","_revertAll","trigger","_clearScrollMemory","rec","_refreshID","_refresh100vh","_hideAllMarkers","hide","skipRevert","isRefreshing","refreshInits","scrollBehavior","refresh","_subPinOffset","pin","original","adjustPinSpacing","scroller","_dir","endClamp","_endClamp","startClamp","_startClamp","setPositions","onRefresh","_lastScroll","_direction","isUpdating","recordVelocity","scroll","_propNamesToCopy","_stateProps","concat","_swapPinIn","spacer","spacerState","swappedIn","spacerStyle","pinStyle","flexBasis","overflow","boxSizing","_setState","state","_getState","_parsePosition","scrollerSize","markerScroller","scrollerBounds","borderWidth","scrollerMax","clampZeroProp","p1","seek","mapRange","scrollTrigger","localOffset","globalOffset","offsets","_caScrollDist","_prefixExp","_reparent","_stOrig","_interruptionTracker","getValueFunc","initialValue","onInterrupt","last1","last2","current","_shiftMarker","_getTweenCreator","getScroll","getTween","change1","change2","onComplete","modifiers","checkForInterruption","inherit","onUpdate","tweenTo","pinCache","snapFunc","scroll1","scroll2","markerStart","markerEnd","markerStartTrigger","markerEndTrigger","markerVars","executingOnRefresh","pinOriginalState","pinActiveState","pinState","pinGetter","pinSetter","pinStart","pinChange","spacingStart","markerStartSetter","pinMoves","markerEndSetter","snap1","snap2","scrubTween","scrubSmooth","snapDurClamp","snapDelayedCall","prevScroll","prevAnimProgress","caMarkerSetter","customRevertReturn","_vars","toggleClass","onToggle","scrub","pinSpacing","invalidateOnRefresh","onScrubComplete","onSnapComplete","once","pinReparent","pinSpacer","fastScrollEnd","preventOverlaps","isToggle","scrollerCache","pinType","callbacks","onEnter","onLeave","onEnterBack","onLeaveBack","markers","onRefreshInit","getScrollerSize","_getSizeFunc","getScrollerOffsets","_getOffsetsFunc","lastSnap","lastRefresh","prevProgress","bind","refreshPriority","tweenScroll","scrubDuration","ease","totalProgress","paused","lazy","_initted","isReverted","immediateRender","snapTo","_getClosestLabel","st","directional","delay","refreshedRecently","isActive","endScroll","velocity","naturalEnd","inertia","_snap","onStart","_onInterrupt","_onComplete","resetTo","_tTime","_tDur","stRevert","nativeElement","spacerIsNative","classList","quickSetter","oldOnUpdate","oldParams","onUpdateParams","eventCallback","previous","next","prevRefreshing","_swapPinOut","soft","pinOffset","invalidate","isVertical","override","curTrigger","curPin","oppositeScroll","initted","revertedPins","forcedOverflow","markerStartOffset","markerEndOffset","isFirstRefresh","otherPinOffset","parsedEnd","parsedEndTrigger","endTrigger","parsedStart","pinnedContainer","triggerIndex","unshift","_pinPush","normalize","_pinOffset","ceil","omitOffsets","_copyState","endAnimation","labelToScroll","label","getTrailing","reverse","forceFake","toggleState","action","stateChanged","toggled","isAtMax","isTakingAction","clipped","_dp","_start","n","newStart","newEnd","keepClamp","_change","allowAnimation","onKill","updateFunc","_queueRefreshAll","clearInterval","suppressOverwrites","userAgent","mm","bodyStyle","border","borderTopStyle","AnimationProto","Animation","setInterval","w","h","hidden","limitCallbacks","ms","syncInterval","ignoreMobileResize","autoRefreshEvents","scrollerProxy","clearMatchMedia","isInViewport","positionInViewport","referencePoint","killAll","allowListeners","listeners","saveStyles","safe","clearScrollMemory","maxScroll","getScrollFunc","isScrolling","snapDirectional","batch","varsCopy","interval","batchMax","proxyCallback","elements","triggers","_inputIsFocused","_clampScrollAndGetDurationMultiplier","_allowNativePanning","touchAction","_overflow","auto","_nestedScroll","_ref5","node","_isScrollT","scrollHeight","clientHeight","scrollWidth","overflowY","overflowX","_isScroll","stopPropagation","_inputObserver","inputs","nested","_captureInputs","_inputExp","isInput","_getScrollNormalizer","maxY","lastRefreshID","skipTouchMove","startScrollX","startScrollY","_vars2","normalizeScrollX","momentum","allowNestedScroll","smoother","ScrollSmoother","smootherInstance","initialScale","visualViewport","outerWidth","wheelRefresh","resolveMomentumDuration","inputObserver","resumeTouchMove","scrollClampX","scrollClampY","updateClamps","removeContentOffset","onResize","ignoreDrag","prevScale","currentScroll","dur","velocityX","velocityY","play","_ts","xArray","yArray","yClamped","ticker","observe","normalizeScroll","normalizer","ss","ref","picture","email","region","phone","headline","src","alt","dangerouslySetInnerHTML","__html","useEffect","tl","opacity","stagger","ContactCard","link","date","image_url","background","background_color","description","panelClass","stack","toggle","setToggle","useState","backgroundImage","setBackgroundImage","screenWidth","async","images","response","fetch","headers","json","floor","random","fetchRandomImage","techs","tech","img","role","tabIndex","onMouseEnter","onMouseLeave","backgroundColor","undefined","projects","sticky","setSticky","setOffset","useRef","log","updateValue","_debounce","val","found","querySelectorAll","article","rect","windowHeight","windowWidth","vertInView","horInView","isElementInViewport","handleScroll","project","Project","frontmatter","html","behavior","challenges","challenge","ChallengeCard","theme","allMarkdownRemark","edges","Layout","basic","Hero","Challenge","disabled","fileAbsolutePath","includes","Projects","Symbol","module","exports","getRawTag","objectToString","symToStringTag","toStringTag","trimmedEndIndex","reTrimStart","string","freeGlobal","g","objectProto","hasOwnProperty","nativeObjectToString","toString","isOwn","tag","unmasked","freeSelf","root","Function","reWhitespace","isObject","toNumber","nativeMax","nativeMin","wait","options","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","args","thisArg","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","leadingEdge","clearTimeout","cancel","flush","baseGetTag","isObjectLike","baseTrim","isSymbol","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","isBinary"],"sourceRoot":""}