{"version":3,"file":"486.js","mappings":"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","sources":["webpack://silverstripe-base/./node_modules/gsap/utils/paths.js","webpack://silverstripe-base/./node_modules/gsap/utils/matrix.js","webpack://silverstripe-base/./node_modules/gsap/MotionPathPlugin.js","webpack://silverstripe-base/./node_modules/gsap/Observer.js","webpack://silverstripe-base/./node_modules/gsap/ScrollTrigger.js"],"sourcesContent":["/*!\n * paths 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 */\nvar _svgPathExp = /[achlmqstvz]|(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[0-9]/ig,\n    _numbersExp = /(?:(-)?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[0-9]/ig,\n    _scientific = /[\\+\\-]?\\d*\\.?\\d+e[\\+\\-]?\\d+/ig,\n    _selectorExp = /(^[#\\.][a-z]|[a-y][a-z])/i,\n    _DEG2RAD = Math.PI / 180,\n    _RAD2DEG = 180 / Math.PI,\n    _sin = Math.sin,\n    _cos = Math.cos,\n    _abs = Math.abs,\n    _sqrt = Math.sqrt,\n    _atan2 = Math.atan2,\n    _largeNum = 1e8,\n    _isString = function _isString(value) {\n  return typeof value === \"string\";\n},\n    _isNumber = function _isNumber(value) {\n  return typeof value === \"number\";\n},\n    _isUndefined = function _isUndefined(value) {\n  return typeof value === \"undefined\";\n},\n    _temp = {},\n    _temp2 = {},\n    _roundingNum = 1e5,\n    _wrapProgress = function _wrapProgress(progress) {\n  return Math.round((progress + _largeNum) % 1 * _roundingNum) / _roundingNum || (progress < 0 ? 0 : 1);\n},\n    //if progress lands on 1, the % will make it 0 which is why we || 1, but not if it's negative because it makes more sense for motion to end at 0 in that case.\n_round = function _round(value) {\n  return Math.round(value * _roundingNum) / _roundingNum || 0;\n},\n    _roundPrecise = function _roundPrecise(value) {\n  return Math.round(value * 1e10) / 1e10 || 0;\n},\n    _splitSegment = function _splitSegment(rawPath, segIndex, i, t) {\n  var segment = rawPath[segIndex],\n      shift = t === 1 ? 6 : subdivideSegment(segment, i, t);\n\n  if ((shift || !t) && shift + i + 2 < segment.length) {\n    rawPath.splice(segIndex, 0, segment.slice(0, i + shift + 2));\n    segment.splice(0, i + shift);\n    return 1;\n  }\n},\n    _getSampleIndex = function _getSampleIndex(samples, length, progress) {\n  // slightly slower way than doing this (when there's no lookup): segment.lookup[progress < 1 ? ~~(length / segment.minLength) : segment.lookup.length - 1] || 0;\n  var l = samples.length,\n      i = ~~(progress * l);\n\n  if (samples[i] > length) {\n    while (--i && samples[i] > length) {}\n\n    i < 0 && (i = 0);\n  } else {\n    while (samples[++i] < length && i < l) {}\n  }\n\n  return i < l ? i : l - 1;\n},\n    _reverseRawPath = function _reverseRawPath(rawPath, skipOuter) {\n  var i = rawPath.length;\n  skipOuter || rawPath.reverse();\n\n  while (i--) {\n    rawPath[i].reversed || reverseSegment(rawPath[i]);\n  }\n},\n    _copyMetaData = function _copyMetaData(source, copy) {\n  copy.totalLength = source.totalLength;\n\n  if (source.samples) {\n    //segment\n    copy.samples = source.samples.slice(0);\n    copy.lookup = source.lookup.slice(0);\n    copy.minLength = source.minLength;\n    copy.resolution = source.resolution;\n  } else if (source.totalPoints) {\n    //rawPath\n    copy.totalPoints = source.totalPoints;\n  }\n\n  return copy;\n},\n    //pushes a new segment into a rawPath, but if its starting values match the ending values of the last segment, it'll merge it into that same segment (to reduce the number of segments)\n_appendOrMerge = function _appendOrMerge(rawPath, segment) {\n  var index = rawPath.length,\n      prevSeg = rawPath[index - 1] || [],\n      l = prevSeg.length;\n\n  if (index && segment[0] === prevSeg[l - 2] && segment[1] === prevSeg[l - 1]) {\n    segment = prevSeg.concat(segment.slice(2));\n    index--;\n  }\n\n  rawPath[index] = segment;\n},\n    _bestDistance;\n/* TERMINOLOGY\n - RawPath - an array of arrays, one for each Segment. A single RawPath could have multiple \"M\" commands, defining Segments (paths aren't always connected).\n - Segment - an array containing a sequence of Cubic Bezier coordinates in alternating x, y, x, y format. Starting anchor, then control point 1, control point 2, and ending anchor, then the next control point 1, control point 2, anchor, etc. Uses less memory than an array with a bunch of {x, y} points.\n - Bezier - a single cubic Bezier with a starting anchor, two control points, and an ending anchor.\n - the variable \"t\" is typically the position along an individual Bezier path (time) and it's NOT linear, meaning it could accelerate/decelerate based on the control points whereas the \"p\" or \"progress\" value is linearly mapped to the whole path, so it shouldn't really accelerate/decelerate based on control points. So a progress of 0.2 would be almost exactly 20% along the path. \"t\" is ONLY in an individual Bezier piece.\n */\n//accepts basic selector text, a path instance, a RawPath instance, or a Segment and returns a RawPath (makes it easy to homogenize things). If an element or selector text is passed in, it'll also cache the value so that if it's queried again, it'll just take the path data from there instead of parsing it all over again (as long as the path data itself hasn't changed - it'll check).\n\n\nexport function getRawPath(value) {\n  value = _isString(value) && _selectorExp.test(value) ? document.querySelector(value) || value : value;\n  var e = value.getAttribute ? value : 0,\n      rawPath;\n\n  if (e && (value = value.getAttribute(\"d\"))) {\n    //implements caching\n    if (!e._gsPath) {\n      e._gsPath = {};\n    }\n\n    rawPath = e._gsPath[value];\n    return rawPath && !rawPath._dirty ? rawPath : e._gsPath[value] = stringToRawPath(value);\n  }\n\n  return !value ? console.warn(\"Expecting a <path> element or an SVG path data string\") : _isString(value) ? stringToRawPath(value) : _isNumber(value[0]) ? [value] : value;\n} //copies a RawPath WITHOUT the length meta data (for speed)\n\nexport function copyRawPath(rawPath) {\n  var a = [],\n      i = 0;\n\n  for (; i < rawPath.length; i++) {\n    a[i] = _copyMetaData(rawPath[i], rawPath[i].slice(0));\n  }\n\n  return _copyMetaData(rawPath, a);\n}\nexport function reverseSegment(segment) {\n  var i = 0,\n      y;\n  segment.reverse(); //this will invert the order y, x, y, x so we must flip it back.\n\n  for (; i < segment.length; i += 2) {\n    y = segment[i];\n    segment[i] = segment[i + 1];\n    segment[i + 1] = y;\n  }\n\n  segment.reversed = !segment.reversed;\n}\n\nvar _createPath = function _createPath(e, ignore) {\n  var path = document.createElementNS(\"http://www.w3.org/2000/svg\", \"path\"),\n      attr = [].slice.call(e.attributes),\n      i = attr.length,\n      name;\n  ignore = \",\" + ignore + \",\";\n\n  while (--i > -1) {\n    name = attr[i].nodeName.toLowerCase(); //in Microsoft Edge, if you don't set the attribute with a lowercase name, it doesn't render correctly! Super weird.\n\n    if (ignore.indexOf(\",\" + name + \",\") < 0) {\n      path.setAttributeNS(null, name, attr[i].nodeValue);\n    }\n  }\n\n  return path;\n},\n    _typeAttrs = {\n  rect: \"rx,ry,x,y,width,height\",\n  circle: \"r,cx,cy\",\n  ellipse: \"rx,ry,cx,cy\",\n  line: \"x1,x2,y1,y2\"\n},\n    _attrToObj = function _attrToObj(e, attrs) {\n  var props = attrs ? attrs.split(\",\") : [],\n      obj = {},\n      i = props.length;\n\n  while (--i > -1) {\n    obj[props[i]] = +e.getAttribute(props[i]) || 0;\n  }\n\n  return obj;\n}; //converts an SVG shape like <circle>, <rect>, <polygon>, <polyline>, <ellipse>, etc. to a <path>, swapping it in and copying the attributes to match.\n\n\nexport function convertToPath(element, swap) {\n  var type = element.tagName.toLowerCase(),\n      circ = 0.552284749831,\n      data,\n      x,\n      y,\n      r,\n      ry,\n      path,\n      rcirc,\n      rycirc,\n      points,\n      w,\n      h,\n      x2,\n      x3,\n      x4,\n      x5,\n      x6,\n      y2,\n      y3,\n      y4,\n      y5,\n      y6,\n      attr;\n\n  if (type === \"path\" || !element.getBBox) {\n    return element;\n  }\n\n  path = _createPath(element, \"x,y,width,height,cx,cy,rx,ry,r,x1,x2,y1,y2,points\");\n  attr = _attrToObj(element, _typeAttrs[type]);\n\n  if (type === \"rect\") {\n    r = attr.rx;\n    ry = attr.ry || r;\n    x = attr.x;\n    y = attr.y;\n    w = attr.width - r * 2;\n    h = attr.height - ry * 2;\n\n    if (r || ry) {\n      //if there are rounded corners, render cubic beziers\n      x2 = x + r * (1 - circ);\n      x3 = x + r;\n      x4 = x3 + w;\n      x5 = x4 + r * circ;\n      x6 = x4 + r;\n      y2 = y + ry * (1 - circ);\n      y3 = y + ry;\n      y4 = y3 + h;\n      y5 = y4 + ry * circ;\n      y6 = y4 + ry;\n      data = \"M\" + x6 + \",\" + y3 + \" V\" + y4 + \" C\" + [x6, y5, x5, y6, x4, y6, x4 - (x4 - x3) / 3, y6, x3 + (x4 - x3) / 3, y6, x3, y6, x2, y6, x, y5, x, y4, x, y4 - (y4 - y3) / 3, x, y3 + (y4 - y3) / 3, x, y3, x, y2, x2, y, x3, y, x3 + (x4 - x3) / 3, y, x4 - (x4 - x3) / 3, y, x4, y, x5, y, x6, y2, x6, y3].join(\",\") + \"z\";\n    } else {\n      data = \"M\" + (x + w) + \",\" + y + \" v\" + h + \" h\" + -w + \" v\" + -h + \" h\" + w + \"z\";\n    }\n  } else if (type === \"circle\" || type === \"ellipse\") {\n    if (type === \"circle\") {\n      r = ry = attr.r;\n      rycirc = r * circ;\n    } else {\n      r = attr.rx;\n      ry = attr.ry;\n      rycirc = ry * circ;\n    }\n\n    x = attr.cx;\n    y = attr.cy;\n    rcirc = r * circ;\n    data = \"M\" + (x + r) + \",\" + y + \" C\" + [x + r, y + rycirc, x + rcirc, y + ry, x, y + ry, x - rcirc, y + ry, x - r, y + rycirc, x - r, y, x - r, y - rycirc, x - rcirc, y - ry, x, y - ry, x + rcirc, y - ry, x + r, y - rycirc, x + r, y].join(\",\") + \"z\";\n  } else if (type === \"line\") {\n    data = \"M\" + attr.x1 + \",\" + attr.y1 + \" L\" + attr.x2 + \",\" + attr.y2; //previously, we just converted to \"Mx,y Lx,y\" but Safari has bugs that cause that not to render properly when using a stroke-dasharray that's not fully visible! Using a cubic bezier fixes that issue.\n  } else if (type === \"polyline\" || type === \"polygon\") {\n    points = (element.getAttribute(\"points\") + \"\").match(_numbersExp) || [];\n    x = points.shift();\n    y = points.shift();\n    data = \"M\" + x + \",\" + y + \" L\" + points.join(\",\");\n\n    if (type === \"polygon\") {\n      data += \",\" + x + \",\" + y + \"z\";\n    }\n  }\n\n  path.setAttribute(\"d\", rawPathToString(path._gsRawPath = stringToRawPath(data)));\n\n  if (swap && element.parentNode) {\n    element.parentNode.insertBefore(path, element);\n    element.parentNode.removeChild(element);\n  }\n\n  return path;\n} //returns the rotation (in degrees) at a particular progress on a rawPath (the slope of the tangent)\n\nexport function getRotationAtProgress(rawPath, progress) {\n  var d = getProgressData(rawPath, progress >= 1 ? 1 - 1e-9 : progress ? progress : 1e-9);\n  return getRotationAtBezierT(d.segment, d.i, d.t);\n}\n\nfunction getRotationAtBezierT(segment, i, t) {\n  var a = segment[i],\n      b = segment[i + 2],\n      c = segment[i + 4],\n      x;\n  a += (b - a) * t;\n  b += (c - b) * t;\n  a += (b - a) * t;\n  x = b + (c + (segment[i + 6] - c) * t - b) * t - a;\n  a = segment[i + 1];\n  b = segment[i + 3];\n  c = segment[i + 5];\n  a += (b - a) * t;\n  b += (c - b) * t;\n  a += (b - a) * t;\n  return _round(_atan2(b + (c + (segment[i + 7] - c) * t - b) * t - a, x) * _RAD2DEG);\n}\n\nexport function sliceRawPath(rawPath, start, end) {\n  end = _isUndefined(end) ? 1 : _roundPrecise(end) || 0; // we must round to avoid issues like 4.15 / 8 = 0.8300000000000001 instead of 0.83 or 2.8 / 5 = 0.5599999999999999 instead of 0.56 and if someone is doing a loop like start: 2.8 / 0.5, end: 2.8 / 0.5 + 1.\n\n  start = _roundPrecise(start) || 0;\n  var loops = Math.max(0, ~~(_abs(end - start) - 1e-8)),\n      path = copyRawPath(rawPath);\n\n  if (start > end) {\n    start = 1 - start;\n    end = 1 - end;\n\n    _reverseRawPath(path);\n\n    path.totalLength = 0;\n  }\n\n  if (start < 0 || end < 0) {\n    var offset = Math.abs(~~Math.min(start, end)) + 1;\n    start += offset;\n    end += offset;\n  }\n\n  path.totalLength || cacheRawPathMeasurements(path);\n  var wrap = end > 1,\n      s = getProgressData(path, start, _temp, true),\n      e = getProgressData(path, end, _temp2),\n      eSeg = e.segment,\n      sSeg = s.segment,\n      eSegIndex = e.segIndex,\n      sSegIndex = s.segIndex,\n      ei = e.i,\n      si = s.i,\n      sameSegment = sSegIndex === eSegIndex,\n      sameBezier = ei === si && sameSegment,\n      wrapsBehind,\n      sShift,\n      eShift,\n      i,\n      copy,\n      totalSegments,\n      l,\n      j;\n\n  if (wrap || loops) {\n    wrapsBehind = eSegIndex < sSegIndex || sameSegment && ei < si || sameBezier && e.t < s.t;\n\n    if (_splitSegment(path, sSegIndex, si, s.t)) {\n      sSegIndex++;\n\n      if (!wrapsBehind) {\n        eSegIndex++;\n\n        if (sameBezier) {\n          e.t = (e.t - s.t) / (1 - s.t);\n          ei = 0;\n        } else if (sameSegment) {\n          ei -= si;\n        }\n      }\n    }\n\n    if (Math.abs(1 - (end - start)) < 1e-5) {\n      eSegIndex = sSegIndex - 1;\n    } else if (!e.t && eSegIndex) {\n      eSegIndex--;\n    } else if (_splitSegment(path, eSegIndex, ei, e.t) && wrapsBehind) {\n      sSegIndex++;\n    }\n\n    if (s.t === 1) {\n      sSegIndex = (sSegIndex + 1) % path.length;\n    }\n\n    copy = [];\n    totalSegments = path.length;\n    l = 1 + totalSegments * loops;\n    j = sSegIndex;\n    l += (totalSegments - sSegIndex + eSegIndex) % totalSegments;\n\n    for (i = 0; i < l; i++) {\n      _appendOrMerge(copy, path[j++ % totalSegments]);\n    }\n\n    path = copy;\n  } else {\n    eShift = e.t === 1 ? 6 : subdivideSegment(eSeg, ei, e.t);\n\n    if (start !== end) {\n      sShift = subdivideSegment(sSeg, si, sameBezier ? s.t / e.t : s.t);\n      sameSegment && (eShift += sShift);\n      eSeg.splice(ei + eShift + 2);\n      (sShift || si) && sSeg.splice(0, si + sShift);\n      i = path.length;\n\n      while (i--) {\n        //chop off any extra segments\n        (i < sSegIndex || i > eSegIndex) && path.splice(i, 1);\n      }\n    } else {\n      eSeg.angle = getRotationAtBezierT(eSeg, ei + eShift, 0); //record the value before we chop because it'll be impossible to determine the angle after its length is 0!\n\n      ei += eShift;\n      s = eSeg[ei];\n      e = eSeg[ei + 1];\n      eSeg.length = eSeg.totalLength = 0;\n      eSeg.totalPoints = path.totalPoints = 8;\n      eSeg.push(s, e, s, e, s, e, s, e);\n    }\n  }\n\n  path.totalLength = 0;\n  return path;\n} //measures a Segment according to its resolution (so if segment.resolution is 6, for example, it'll take 6 samples equally across each Bezier) and create/populate a \"samples\" Array that has the length up to each of those sample points (always increasing from the start) as well as a \"lookup\" array that's broken up according to the smallest distance between 2 samples. This gives us a very fast way of looking up a progress position rather than looping through all the points/Beziers. You can optionally have it only measure a subset, starting at startIndex and going for a specific number of beziers (remember, there are 3 x/y pairs each, for a total of 6 elements for each Bezier). It will also populate a \"totalLength\" property, but that's not generally super accurate because by default it'll only take 6 samples per Bezier. But for performance reasons, it's perfectly adequate for measuring progress values along the path. If you need a more accurate totalLength, either increase the resolution or use the more advanced bezierToPoints() method which keeps adding points until they don't deviate by more than a certain precision value.\n\nfunction measureSegment(segment, startIndex, bezierQty) {\n  startIndex = startIndex || 0;\n\n  if (!segment.samples) {\n    segment.samples = [];\n    segment.lookup = [];\n  }\n\n  var resolution = ~~segment.resolution || 12,\n      inc = 1 / resolution,\n      endIndex = bezierQty ? startIndex + bezierQty * 6 + 1 : segment.length,\n      x1 = segment[startIndex],\n      y1 = segment[startIndex + 1],\n      samplesIndex = startIndex ? startIndex / 6 * resolution : 0,\n      samples = segment.samples,\n      lookup = segment.lookup,\n      min = (startIndex ? segment.minLength : _largeNum) || _largeNum,\n      prevLength = samples[samplesIndex + bezierQty * resolution - 1],\n      length = startIndex ? samples[samplesIndex - 1] : 0,\n      i,\n      j,\n      x4,\n      x3,\n      x2,\n      xd,\n      xd1,\n      y4,\n      y3,\n      y2,\n      yd,\n      yd1,\n      inv,\n      t,\n      lengthIndex,\n      l,\n      segLength;\n  samples.length = lookup.length = 0;\n\n  for (j = startIndex + 2; j < endIndex; j += 6) {\n    x4 = segment[j + 4] - x1;\n    x3 = segment[j + 2] - x1;\n    x2 = segment[j] - x1;\n    y4 = segment[j + 5] - y1;\n    y3 = segment[j + 3] - y1;\n    y2 = segment[j + 1] - y1;\n    xd = xd1 = yd = yd1 = 0;\n\n    if (_abs(x4) < .01 && _abs(y4) < .01 && _abs(x2) + _abs(y2) < .01) {\n      //dump points that are sufficiently close (basically right on top of each other, making a bezier super tiny or 0 length)\n      if (segment.length > 8) {\n        segment.splice(j, 6);\n        j -= 6;\n        endIndex -= 6;\n      }\n    } else {\n      for (i = 1; i <= resolution; i++) {\n        t = inc * i;\n        inv = 1 - t;\n        xd = xd1 - (xd1 = (t * t * x4 + 3 * inv * (t * x3 + inv * x2)) * t);\n        yd = yd1 - (yd1 = (t * t * y4 + 3 * inv * (t * y3 + inv * y2)) * t);\n        l = _sqrt(yd * yd + xd * xd);\n\n        if (l < min) {\n          min = l;\n        }\n\n        length += l;\n        samples[samplesIndex++] = length;\n      }\n    }\n\n    x1 += x4;\n    y1 += y4;\n  }\n\n  if (prevLength) {\n    prevLength -= length;\n\n    for (; samplesIndex < samples.length; samplesIndex++) {\n      samples[samplesIndex] += prevLength;\n    }\n  }\n\n  if (samples.length && min) {\n    segment.totalLength = segLength = samples[samples.length - 1] || 0;\n    segment.minLength = min;\n\n    if (segLength / min < 9999) {\n      // if the lookup would require too many values (memory problem), we skip this and instead we use a loop to lookup values directly in the samples Array\n      l = lengthIndex = 0;\n\n      for (i = 0; i < segLength; i += min) {\n        lookup[l++] = samples[lengthIndex] < i ? ++lengthIndex : lengthIndex;\n      }\n    }\n  } else {\n    segment.totalLength = samples[0] = 0;\n  }\n\n  return startIndex ? length - samples[startIndex / 2 - 1] : length;\n}\n\nexport function cacheRawPathMeasurements(rawPath, resolution) {\n  var pathLength, points, i;\n\n  for (i = pathLength = points = 0; i < rawPath.length; i++) {\n    rawPath[i].resolution = ~~resolution || 12; //steps per Bezier curve (anchor, 2 control points, to anchor)\n\n    points += rawPath[i].length;\n    pathLength += measureSegment(rawPath[i]);\n  }\n\n  rawPath.totalPoints = points;\n  rawPath.totalLength = pathLength;\n  return rawPath;\n} //divide segment[i] at position t (value between 0 and 1, progress along that particular cubic bezier segment that starts at segment[i]). Returns how many elements were spliced into the segment array (either 0 or 6)\n\nexport function subdivideSegment(segment, i, t) {\n  if (t <= 0 || t >= 1) {\n    return 0;\n  }\n\n  var ax = segment[i],\n      ay = segment[i + 1],\n      cp1x = segment[i + 2],\n      cp1y = segment[i + 3],\n      cp2x = segment[i + 4],\n      cp2y = segment[i + 5],\n      bx = segment[i + 6],\n      by = segment[i + 7],\n      x1a = ax + (cp1x - ax) * t,\n      x2 = cp1x + (cp2x - cp1x) * t,\n      y1a = ay + (cp1y - ay) * t,\n      y2 = cp1y + (cp2y - cp1y) * t,\n      x1 = x1a + (x2 - x1a) * t,\n      y1 = y1a + (y2 - y1a) * t,\n      x2a = cp2x + (bx - cp2x) * t,\n      y2a = cp2y + (by - cp2y) * t;\n  x2 += (x2a - x2) * t;\n  y2 += (y2a - y2) * t;\n  segment.splice(i + 2, 4, _round(x1a), //first control point\n  _round(y1a), _round(x1), //second control point\n  _round(y1), _round(x1 + (x2 - x1) * t), //new fabricated anchor on line\n  _round(y1 + (y2 - y1) * t), _round(x2), //third control point\n  _round(y2), _round(x2a), //fourth control point\n  _round(y2a));\n  segment.samples && segment.samples.splice(i / 6 * segment.resolution | 0, 0, 0, 0, 0, 0, 0, 0);\n  return 6;\n} // returns an object {path, segment, segIndex, i, t}\n\nfunction getProgressData(rawPath, progress, decoratee, pushToNextIfAtEnd) {\n  decoratee = decoratee || {};\n  rawPath.totalLength || cacheRawPathMeasurements(rawPath);\n\n  if (progress < 0 || progress > 1) {\n    progress = _wrapProgress(progress);\n  }\n\n  var segIndex = 0,\n      segment = rawPath[0],\n      samples,\n      resolution,\n      length,\n      min,\n      max,\n      i,\n      t;\n\n  if (!progress) {\n    t = i = segIndex = 0;\n    segment = rawPath[0];\n  } else if (progress === 1) {\n    t = 1;\n    segIndex = rawPath.length - 1;\n    segment = rawPath[segIndex];\n    i = segment.length - 8;\n  } else {\n    if (rawPath.length > 1) {\n      //speed optimization: most of the time, there's only one segment so skip the recursion.\n      length = rawPath.totalLength * progress;\n      max = i = 0;\n\n      while ((max += rawPath[i++].totalLength) < length) {\n        segIndex = i;\n      }\n\n      segment = rawPath[segIndex];\n      min = max - segment.totalLength;\n      progress = (length - min) / (max - min) || 0;\n    }\n\n    samples = segment.samples;\n    resolution = segment.resolution; //how many samples per cubic bezier chunk\n\n    length = segment.totalLength * progress;\n    i = segment.lookup.length ? segment.lookup[~~(length / segment.minLength)] || 0 : _getSampleIndex(samples, length, progress);\n    min = i ? samples[i - 1] : 0;\n    max = samples[i];\n\n    if (max < length) {\n      min = max;\n      max = samples[++i];\n    }\n\n    t = 1 / resolution * ((length - min) / (max - min) + i % resolution);\n    i = ~~(i / resolution) * 6;\n\n    if (pushToNextIfAtEnd && t === 1) {\n      if (i + 6 < segment.length) {\n        i += 6;\n        t = 0;\n      } else if (segIndex + 1 < rawPath.length) {\n        i = t = 0;\n        segment = rawPath[++segIndex];\n      }\n    }\n  }\n\n  decoratee.t = t;\n  decoratee.i = i;\n  decoratee.path = rawPath;\n  decoratee.segment = segment;\n  decoratee.segIndex = segIndex;\n  return decoratee;\n}\n\nexport function getPositionOnPath(rawPath, progress, includeAngle, point) {\n  var segment = rawPath[0],\n      result = point || {},\n      samples,\n      resolution,\n      length,\n      min,\n      max,\n      i,\n      t,\n      a,\n      inv;\n\n  if (progress < 0 || progress > 1) {\n    progress = _wrapProgress(progress);\n  }\n\n  segment.lookup || cacheRawPathMeasurements(rawPath);\n\n  if (rawPath.length > 1) {\n    //speed optimization: most of the time, there's only one segment so skip the recursion.\n    length = rawPath.totalLength * progress;\n    max = i = 0;\n\n    while ((max += rawPath[i++].totalLength) < length) {\n      segment = rawPath[i];\n    }\n\n    min = max - segment.totalLength;\n    progress = (length - min) / (max - min) || 0;\n  }\n\n  samples = segment.samples;\n  resolution = segment.resolution;\n  length = segment.totalLength * progress;\n  i = segment.lookup.length ? segment.lookup[progress < 1 ? ~~(length / segment.minLength) : segment.lookup.length - 1] || 0 : _getSampleIndex(samples, length, progress);\n  min = i ? samples[i - 1] : 0;\n  max = samples[i];\n\n  if (max < length) {\n    min = max;\n    max = samples[++i];\n  }\n\n  t = 1 / resolution * ((length - min) / (max - min) + i % resolution) || 0;\n  inv = 1 - t;\n  i = ~~(i / resolution) * 6;\n  a = segment[i];\n  result.x = _round((t * t * (segment[i + 6] - a) + 3 * inv * (t * (segment[i + 4] - a) + inv * (segment[i + 2] - a))) * t + a);\n  result.y = _round((t * t * (segment[i + 7] - (a = segment[i + 1])) + 3 * inv * (t * (segment[i + 5] - a) + inv * (segment[i + 3] - a))) * t + a);\n\n  if (includeAngle) {\n    result.angle = segment.totalLength ? getRotationAtBezierT(segment, i, t >= 1 ? 1 - 1e-9 : t ? t : 1e-9) : segment.angle || 0;\n  }\n\n  return result;\n} //applies a matrix transform to RawPath (or a segment in a RawPath) and returns whatever was passed in (it transforms the values in the array(s), not a copy).\n\nexport function transformRawPath(rawPath, a, b, c, d, tx, ty) {\n  var j = rawPath.length,\n      segment,\n      l,\n      i,\n      x,\n      y;\n\n  while (--j > -1) {\n    segment = rawPath[j];\n    l = segment.length;\n\n    for (i = 0; i < l; i += 2) {\n      x = segment[i];\n      y = segment[i + 1];\n      segment[i] = x * a + y * c + tx;\n      segment[i + 1] = x * b + y * d + ty;\n    }\n  }\n\n  rawPath._dirty = 1;\n  return rawPath;\n} // translates SVG arc data into a segment (cubic beziers). Angle is in degrees.\n\nfunction arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) {\n  if (lastX === x && lastY === y) {\n    return;\n  }\n\n  rx = _abs(rx);\n  ry = _abs(ry);\n\n  var angleRad = angle % 360 * _DEG2RAD,\n      cosAngle = _cos(angleRad),\n      sinAngle = _sin(angleRad),\n      PI = Math.PI,\n      TWOPI = PI * 2,\n      dx2 = (lastX - x) / 2,\n      dy2 = (lastY - y) / 2,\n      x1 = cosAngle * dx2 + sinAngle * dy2,\n      y1 = -sinAngle * dx2 + cosAngle * dy2,\n      x1_sq = x1 * x1,\n      y1_sq = y1 * y1,\n      radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry);\n\n  if (radiiCheck > 1) {\n    rx = _sqrt(radiiCheck) * rx;\n    ry = _sqrt(radiiCheck) * ry;\n  }\n\n  var rx_sq = rx * rx,\n      ry_sq = ry * ry,\n      sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq);\n\n  if (sq < 0) {\n    sq = 0;\n  }\n\n  var coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt(sq),\n      cx1 = coef * (rx * y1 / ry),\n      cy1 = coef * -(ry * x1 / rx),\n      sx2 = (lastX + x) / 2,\n      sy2 = (lastY + y) / 2,\n      cx = sx2 + (cosAngle * cx1 - sinAngle * cy1),\n      cy = sy2 + (sinAngle * cx1 + cosAngle * cy1),\n      ux = (x1 - cx1) / rx,\n      uy = (y1 - cy1) / ry,\n      vx = (-x1 - cx1) / rx,\n      vy = (-y1 - cy1) / ry,\n      temp = ux * ux + uy * uy,\n      angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt(temp)),\n      angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt(temp * (vx * vx + vy * vy)));\n\n  isNaN(angleExtent) && (angleExtent = PI); //rare edge case. Math.cos(-1) is NaN.\n\n  if (!sweepFlag && angleExtent > 0) {\n    angleExtent -= TWOPI;\n  } else if (sweepFlag && angleExtent < 0) {\n    angleExtent += TWOPI;\n  }\n\n  angleStart %= TWOPI;\n  angleExtent %= TWOPI;\n\n  var segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)),\n      rawPath = [],\n      angleIncrement = angleExtent / segments,\n      controlLength = 4 / 3 * _sin(angleIncrement / 2) / (1 + _cos(angleIncrement / 2)),\n      ma = cosAngle * rx,\n      mb = sinAngle * rx,\n      mc = sinAngle * -ry,\n      md = cosAngle * ry,\n      i;\n\n  for (i = 0; i < segments; i++) {\n    angle = angleStart + i * angleIncrement;\n    x1 = _cos(angle);\n    y1 = _sin(angle);\n    ux = _cos(angle += angleIncrement);\n    uy = _sin(angle);\n    rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy);\n  } //now transform according to the actual size of the ellipse/arc (the beziers were noramlized, between 0 and 1 on a circle).\n\n\n  for (i = 0; i < rawPath.length; i += 2) {\n    x1 = rawPath[i];\n    y1 = rawPath[i + 1];\n    rawPath[i] = x1 * ma + y1 * mc + cx;\n    rawPath[i + 1] = x1 * mb + y1 * md + cy;\n  }\n\n  rawPath[i - 2] = x; //always set the end to exactly where it's supposed to be\n\n  rawPath[i - 1] = y;\n  return rawPath;\n} //Spits back a RawPath with absolute coordinates. Each segment starts with a \"moveTo\" command (x coordinate, then y) and then 2 control points (x, y, x, y), then anchor. The goal is to minimize memory and maximize speed.\n\n\nexport function stringToRawPath(d) {\n  var a = (d + \"\").replace(_scientific, function (m) {\n    var n = +m;\n    return n < 0.0001 && n > -0.0001 ? 0 : n;\n  }).match(_svgPathExp) || [],\n      //some authoring programs spit out very small numbers in scientific notation like \"1e-5\", so make sure we round that down to 0 first.\n  path = [],\n      relativeX = 0,\n      relativeY = 0,\n      twoThirds = 2 / 3,\n      elements = a.length,\n      points = 0,\n      errorMessage = \"ERROR: malformed path: \" + d,\n      i,\n      j,\n      x,\n      y,\n      command,\n      isRelative,\n      segment,\n      startX,\n      startY,\n      difX,\n      difY,\n      beziers,\n      prevCommand,\n      flag1,\n      flag2,\n      line = function line(sx, sy, ex, ey) {\n    difX = (ex - sx) / 3;\n    difY = (ey - sy) / 3;\n    segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey);\n  };\n\n  if (!d || !isNaN(a[0]) || isNaN(a[1])) {\n    console.log(errorMessage);\n    return path;\n  }\n\n  for (i = 0; i < elements; i++) {\n    prevCommand = command;\n\n    if (isNaN(a[i])) {\n      command = a[i].toUpperCase();\n      isRelative = command !== a[i]; //lower case means relative\n    } else {\n      //commands like \"C\" can be strung together without any new command characters between.\n      i--;\n    }\n\n    x = +a[i + 1];\n    y = +a[i + 2];\n\n    if (isRelative) {\n      x += relativeX;\n      y += relativeY;\n    }\n\n    if (!i) {\n      startX = x;\n      startY = y;\n    } // \"M\" (move)\n\n\n    if (command === \"M\") {\n      if (segment) {\n        if (segment.length < 8) {\n          //if the path data was funky and just had a M with no actual drawing anywhere, skip it.\n          path.length -= 1;\n        } else {\n          points += segment.length;\n        }\n      }\n\n      relativeX = startX = x;\n      relativeY = startY = y;\n      segment = [x, y];\n      path.push(segment);\n      i += 2;\n      command = \"L\"; //an \"M\" with more than 2 values gets interpreted as \"lineTo\" commands (\"L\").\n      // \"C\" (cubic bezier)\n    } else if (command === \"C\") {\n      if (!segment) {\n        segment = [0, 0];\n      }\n\n      if (!isRelative) {\n        relativeX = relativeY = 0;\n      } //note: \"*1\" is just a fast/short way to cast the value as a Number. WAAAY faster in Chrome, slightly slower in Firefox.\n\n\n      segment.push(x, y, relativeX + a[i + 3] * 1, relativeY + a[i + 4] * 1, relativeX += a[i + 5] * 1, relativeY += a[i + 6] * 1);\n      i += 6; // \"S\" (continuation of cubic bezier)\n    } else if (command === \"S\") {\n      difX = relativeX;\n      difY = relativeY;\n\n      if (prevCommand === \"C\" || prevCommand === \"S\") {\n        difX += relativeX - segment[segment.length - 4];\n        difY += relativeY - segment[segment.length - 3];\n      }\n\n      if (!isRelative) {\n        relativeX = relativeY = 0;\n      }\n\n      segment.push(difX, difY, x, y, relativeX += a[i + 3] * 1, relativeY += a[i + 4] * 1);\n      i += 4; // \"Q\" (quadratic bezier)\n    } else if (command === \"Q\") {\n      difX = relativeX + (x - relativeX) * twoThirds;\n      difY = relativeY + (y - relativeY) * twoThirds;\n\n      if (!isRelative) {\n        relativeX = relativeY = 0;\n      }\n\n      relativeX += a[i + 3] * 1;\n      relativeY += a[i + 4] * 1;\n      segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY);\n      i += 4; // \"T\" (continuation of quadratic bezier)\n    } else if (command === \"T\") {\n      difX = relativeX - segment[segment.length - 4];\n      difY = relativeY - segment[segment.length - 3];\n      segment.push(relativeX + difX, relativeY + difY, x + (relativeX + difX * 1.5 - x) * twoThirds, y + (relativeY + difY * 1.5 - y) * twoThirds, relativeX = x, relativeY = y);\n      i += 2; // \"H\" (horizontal line)\n    } else if (command === \"H\") {\n      line(relativeX, relativeY, relativeX = x, relativeY);\n      i += 1; // \"V\" (vertical line)\n    } else if (command === \"V\") {\n      //adjust values because the first (and only one) isn't x in this case, it's y.\n      line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0));\n      i += 1; // \"L\" (line) or \"Z\" (close)\n    } else if (command === \"L\" || command === \"Z\") {\n      if (command === \"Z\") {\n        x = startX;\n        y = startY;\n        segment.closed = true;\n      }\n\n      if (command === \"L\" || _abs(relativeX - x) > 0.5 || _abs(relativeY - y) > 0.5) {\n        line(relativeX, relativeY, x, y);\n\n        if (command === \"L\") {\n          i += 2;\n        }\n      }\n\n      relativeX = x;\n      relativeY = y; // \"A\" (arc)\n    } else if (command === \"A\") {\n      flag1 = a[i + 4];\n      flag2 = a[i + 5];\n      difX = a[i + 6];\n      difY = a[i + 7];\n      j = 7;\n\n      if (flag1.length > 1) {\n        // for cases when the flags are merged, like \"a8 8 0 018 8\" (the 0 and 1 flags are WITH the x value of 8, but it could also be \"a8 8 0 01-8 8\" so it may include x or not)\n        if (flag1.length < 3) {\n          difY = difX;\n          difX = flag2;\n          j--;\n        } else {\n          difY = flag2;\n          difX = flag1.substr(2);\n          j -= 2;\n        }\n\n        flag2 = flag1.charAt(1);\n        flag1 = flag1.charAt(0);\n      }\n\n      beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + difX * 1, (isRelative ? relativeY : 0) + difY * 1);\n      i += j;\n\n      if (beziers) {\n        for (j = 0; j < beziers.length; j++) {\n          segment.push(beziers[j]);\n        }\n      }\n\n      relativeX = segment[segment.length - 2];\n      relativeY = segment[segment.length - 1];\n    } else {\n      console.log(errorMessage);\n    }\n  }\n\n  i = segment.length;\n\n  if (i < 6) {\n    //in case there's odd SVG like a M0,0 command at the very end.\n    path.pop();\n    i = 0;\n  } else if (segment[0] === segment[i - 2] && segment[1] === segment[i - 1]) {\n    segment.closed = true;\n  }\n\n  path.totalPoints = points + i;\n  return path;\n} //populates the points array in alternating x/y values (like [x, y, x, y...] instead of individual point objects [{x, y}, {x, y}...] to conserve memory and stay in line with how we're handling segment arrays\n\nexport function bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {\n  var x12 = (x1 + x2) / 2,\n      y12 = (y1 + y2) / 2,\n      x23 = (x2 + x3) / 2,\n      y23 = (y2 + y3) / 2,\n      x34 = (x3 + x4) / 2,\n      y34 = (y3 + y4) / 2,\n      x123 = (x12 + x23) / 2,\n      y123 = (y12 + y23) / 2,\n      x234 = (x23 + x34) / 2,\n      y234 = (y23 + y34) / 2,\n      x1234 = (x123 + x234) / 2,\n      y1234 = (y123 + y234) / 2,\n      dx = x4 - x1,\n      dy = y4 - y1,\n      d2 = _abs((x2 - x4) * dy - (y2 - y4) * dx),\n      d3 = _abs((x3 - x4) * dy - (y3 - y4) * dx),\n      length;\n\n  if (!points) {\n    points = [x1, y1, x4, y4];\n    index = 2;\n  }\n\n  points.splice(index || points.length - 2, 0, x1234, y1234);\n\n  if ((d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy)) {\n    length = points.length;\n    bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index);\n    bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 2 + (points.length - length));\n  }\n\n  return points;\n}\n/*\nfunction getAngleBetweenPoints(x0, y0, x1, y1, x2, y2) { //angle between 3 points in radians\n\tvar dx1 = x1 - x0,\n\t\tdy1 = y1 - y0,\n\t\tdx2 = x2 - x1,\n\t\tdy2 = y2 - y1,\n\t\tdx3 = x2 - x0,\n\t\tdy3 = y2 - y0,\n\t\ta = dx1 * dx1 + dy1 * dy1,\n\t\tb = dx2 * dx2 + dy2 * dy2,\n\t\tc = dx3 * dx3 + dy3 * dy3;\n\treturn Math.acos( (a + b - c) / _sqrt(4 * a * b) );\n},\n*/\n//pointsToSegment() doesn't handle flat coordinates (where y is always 0) the way we need (the resulting control points are always right on top of the anchors), so this function basically makes the control points go directly up and down, varying in length based on the curviness (more curvy, further control points)\n\nexport function flatPointsToSegment(points, curviness) {\n  if (curviness === void 0) {\n    curviness = 1;\n  }\n\n  var x = points[0],\n      y = 0,\n      segment = [x, y],\n      i = 2;\n\n  for (; i < points.length; i += 2) {\n    segment.push(x, y, points[i], y = (points[i] - x) * curviness / 2, x = points[i], -y);\n  }\n\n  return segment;\n} //points is an array of x/y points, like [x, y, x, y, x, y]\n\nexport function pointsToSegment(points, curviness) {\n  //points = simplifyPoints(points, tolerance);\n  _abs(points[0] - points[2]) < 1e-4 && _abs(points[1] - points[3]) < 1e-4 && (points = points.slice(2)); // if the first two points are super close, dump the first one.\n\n  var l = points.length - 2,\n      x = +points[0],\n      y = +points[1],\n      nextX = +points[2],\n      nextY = +points[3],\n      segment = [x, y, x, y],\n      dx2 = nextX - x,\n      dy2 = nextY - y,\n      closed = Math.abs(points[l] - x) < 0.001 && Math.abs(points[l + 1] - y) < 0.001,\n      prevX,\n      prevY,\n      i,\n      dx1,\n      dy1,\n      r1,\n      r2,\n      r3,\n      tl,\n      mx1,\n      mx2,\n      mxm,\n      my1,\n      my2,\n      mym;\n\n  if (closed) {\n    // if the start and end points are basically on top of each other, close the segment by adding the 2nd point to the end, and the 2nd-to-last point to the beginning (we'll remove them at the end, but this allows the curvature to look perfect)\n    points.push(nextX, nextY);\n    nextX = x;\n    nextY = y;\n    x = points[l - 2];\n    y = points[l - 1];\n    points.unshift(x, y);\n    l += 4;\n  }\n\n  curviness = curviness || curviness === 0 ? +curviness : 1;\n\n  for (i = 2; i < l; i += 2) {\n    prevX = x;\n    prevY = y;\n    x = nextX;\n    y = nextY;\n    nextX = +points[i + 2];\n    nextY = +points[i + 3];\n\n    if (x === nextX && y === nextY) {\n      continue;\n    }\n\n    dx1 = dx2;\n    dy1 = dy2;\n    dx2 = nextX - x;\n    dy2 = nextY - y;\n    r1 = _sqrt(dx1 * dx1 + dy1 * dy1); // r1, r2, and r3 correlate x and y (and z in the future). Basically 2D or 3D hypotenuse\n\n    r2 = _sqrt(dx2 * dx2 + dy2 * dy2);\n    r3 = _sqrt(Math.pow(dx2 / r2 + dx1 / r1, 2) + Math.pow(dy2 / r2 + dy1 / r1, 2));\n    tl = (r1 + r2) * curviness * 0.25 / r3;\n    mx1 = x - (x - prevX) * (r1 ? tl / r1 : 0);\n    mx2 = x + (nextX - x) * (r2 ? tl / r2 : 0);\n    mxm = x - (mx1 + ((mx2 - mx1) * (r1 * 3 / (r1 + r2) + 0.5) / 4 || 0));\n    my1 = y - (y - prevY) * (r1 ? tl / r1 : 0);\n    my2 = y + (nextY - y) * (r2 ? tl / r2 : 0);\n    mym = y - (my1 + ((my2 - my1) * (r1 * 3 / (r1 + r2) + 0.5) / 4 || 0));\n\n    if (x !== prevX || y !== prevY) {\n      segment.push(_round(mx1 + mxm), // first control point\n      _round(my1 + mym), _round(x), // anchor\n      _round(y), _round(mx2 + mxm), // second control point\n      _round(my2 + mym));\n    }\n  }\n\n  x !== nextX || y !== nextY || segment.length < 4 ? segment.push(_round(nextX), _round(nextY), _round(nextX), _round(nextY)) : segment.length -= 2;\n\n  if (segment.length === 2) {\n    // only one point!\n    segment.push(x, y, x, y, x, y);\n  } else if (closed) {\n    segment.splice(0, 6);\n    segment.length = segment.length - 6;\n  }\n\n  return segment;\n} //returns the squared distance between an x/y coordinate and a segment between x1/y1 and x2/y2\n\nfunction pointToSegDist(x, y, x1, y1, x2, y2) {\n  var dx = x2 - x1,\n      dy = y2 - y1,\n      t;\n\n  if (dx || dy) {\n    t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);\n\n    if (t > 1) {\n      x1 = x2;\n      y1 = y2;\n    } else if (t > 0) {\n      x1 += dx * t;\n      y1 += dy * t;\n    }\n  }\n\n  return Math.pow(x - x1, 2) + Math.pow(y - y1, 2);\n}\n\nfunction simplifyStep(points, first, last, tolerance, simplified) {\n  var maxSqDist = tolerance,\n      firstX = points[first],\n      firstY = points[first + 1],\n      lastX = points[last],\n      lastY = points[last + 1],\n      index,\n      i,\n      d;\n\n  for (i = first + 2; i < last; i += 2) {\n    d = pointToSegDist(points[i], points[i + 1], firstX, firstY, lastX, lastY);\n\n    if (d > maxSqDist) {\n      index = i;\n      maxSqDist = d;\n    }\n  }\n\n  if (maxSqDist > tolerance) {\n    index - first > 2 && simplifyStep(points, first, index, tolerance, simplified);\n    simplified.push(points[index], points[index + 1]);\n    last - index > 2 && simplifyStep(points, index, last, tolerance, simplified);\n  }\n} //points is an array of x/y values like [x, y, x, y, x, y]\n\n\nexport function simplifyPoints(points, tolerance) {\n  var prevX = parseFloat(points[0]),\n      prevY = parseFloat(points[1]),\n      temp = [prevX, prevY],\n      l = points.length - 2,\n      i,\n      x,\n      y,\n      dx,\n      dy,\n      result,\n      last;\n  tolerance = Math.pow(tolerance || 1, 2);\n\n  for (i = 2; i < l; i += 2) {\n    x = parseFloat(points[i]);\n    y = parseFloat(points[i + 1]);\n    dx = prevX - x;\n    dy = prevY - y;\n\n    if (dx * dx + dy * dy > tolerance) {\n      temp.push(x, y);\n      prevX = x;\n      prevY = y;\n    }\n  }\n\n  temp.push(parseFloat(points[l]), parseFloat(points[l + 1]));\n  last = temp.length - 2;\n  result = [temp[0], temp[1]];\n  simplifyStep(temp, 0, last, tolerance, result);\n  result.push(temp[last], temp[last + 1]);\n  return result;\n}\n\nfunction getClosestProgressOnBezier(iterations, px, py, start, end, slices, x0, y0, x1, y1, x2, y2, x3, y3) {\n  var inc = (end - start) / slices,\n      best = 0,\n      t = start,\n      x,\n      y,\n      d,\n      dx,\n      dy,\n      inv;\n  _bestDistance = _largeNum;\n\n  while (t <= end) {\n    inv = 1 - t;\n    x = inv * inv * inv * x0 + 3 * inv * inv * t * x1 + 3 * inv * t * t * x2 + t * t * t * x3;\n    y = inv * inv * inv * y0 + 3 * inv * inv * t * y1 + 3 * inv * t * t * y2 + t * t * t * y3;\n    dx = x - px;\n    dy = y - py;\n    d = dx * dx + dy * dy;\n\n    if (d < _bestDistance) {\n      _bestDistance = d;\n      best = t;\n    }\n\n    t += inc;\n  }\n\n  return iterations > 1 ? getClosestProgressOnBezier(iterations - 1, px, py, Math.max(best - inc, 0), Math.min(best + inc, 1), slices, x0, y0, x1, y1, x2, y2, x3, y3) : best;\n}\n\nexport function getClosestData(rawPath, x, y, slices) {\n  //returns an object with the closest j, i, and t (j is the segment index, i is the index of the point in that segment, and t is the time/progress along that bezier)\n  var closest = {\n    j: 0,\n    i: 0,\n    t: 0\n  },\n      bestDistance = _largeNum,\n      i,\n      j,\n      t,\n      segment;\n\n  for (j = 0; j < rawPath.length; j++) {\n    segment = rawPath[j];\n\n    for (i = 0; i < segment.length; i += 6) {\n      t = getClosestProgressOnBezier(1, x, y, 0, 1, slices || 20, segment[i], segment[i + 1], segment[i + 2], segment[i + 3], segment[i + 4], segment[i + 5], segment[i + 6], segment[i + 7]);\n\n      if (bestDistance > _bestDistance) {\n        bestDistance = _bestDistance;\n        closest.j = j;\n        closest.i = i;\n        closest.t = t;\n      }\n    }\n  }\n\n  return closest;\n} //subdivide a Segment closest to a specific x,y coordinate\n\nexport function subdivideSegmentNear(x, y, segment, slices, iterations) {\n  var l = segment.length,\n      bestDistance = _largeNum,\n      bestT = 0,\n      bestSegmentIndex = 0,\n      t,\n      i;\n  slices = slices || 20;\n  iterations = iterations || 3;\n\n  for (i = 0; i < l; i += 6) {\n    t = getClosestProgressOnBezier(1, x, y, 0, 1, slices, segment[i], segment[i + 1], segment[i + 2], segment[i + 3], segment[i + 4], segment[i + 5], segment[i + 6], segment[i + 7]);\n\n    if (bestDistance > _bestDistance) {\n      bestDistance = _bestDistance;\n      bestT = t;\n      bestSegmentIndex = i;\n    }\n  }\n\n  t = getClosestProgressOnBezier(iterations, x, y, bestT - 0.05, bestT + 0.05, slices, segment[bestSegmentIndex], segment[bestSegmentIndex + 1], segment[bestSegmentIndex + 2], segment[bestSegmentIndex + 3], segment[bestSegmentIndex + 4], segment[bestSegmentIndex + 5], segment[bestSegmentIndex + 6], segment[bestSegmentIndex + 7]);\n  subdivideSegment(segment, bestSegmentIndex, t);\n  return bestSegmentIndex + 6;\n}\n/*\nTakes any of the following and converts it to an all Cubic Bezier SVG data string:\n- A <path> data string like \"M0,0 L2,4 v20,15 H100\"\n- A RawPath, like [[x, y, x, y, x, y, x, y][[x, y, x, y, x, y, x, y]]\n- A Segment, like [x, y, x, y, x, y, x, y]\n\nNote: all numbers are rounded down to the closest 0.001 to minimize memory, maximize speed, and avoid odd numbers like 1e-13\n*/\n\nexport function rawPathToString(rawPath) {\n  if (_isNumber(rawPath[0])) {\n    //in case a segment is passed in instead\n    rawPath = [rawPath];\n  }\n\n  var result = \"\",\n      l = rawPath.length,\n      sl,\n      s,\n      i,\n      segment;\n\n  for (s = 0; s < l; s++) {\n    segment = rawPath[s];\n    result += \"M\" + _round(segment[0]) + \",\" + _round(segment[1]) + \" C\";\n    sl = segment.length;\n\n    for (i = 2; i < sl; i++) {\n      result += _round(segment[i++]) + \",\" + _round(segment[i++]) + \" \" + _round(segment[i++]) + \",\" + _round(segment[i++]) + \" \" + _round(segment[i++]) + \",\" + _round(segment[i]) + \" \";\n    }\n\n    if (segment.closed) {\n      result += \"z\";\n    }\n  }\n\n  return result;\n}\n/*\n// takes a segment with coordinates [x, y, x, y, ...] and converts the control points into angles and lengths [x, y, angle, length, angle, length, x, y, angle, length, ...] so that it animates more cleanly and avoids odd breaks/kinks. For example, if you animate from 1 o'clock to 6 o'clock, it'd just go directly/linearly rather than around. So the length would be very short in the middle of the tween.\nexport function cpCoordsToAngles(segment, copy) {\n\tvar result = copy ? segment.slice(0) : segment,\n\t\tx, y, i;\n\tfor (i = 0; i < segment.length; i+=6) {\n\t\tx = segment[i+2] - segment[i];\n\t\ty = segment[i+3] - segment[i+1];\n\t\tresult[i+2] = Math.atan2(y, x);\n\t\tresult[i+3] = Math.sqrt(x * x + y * y);\n\t\tx = segment[i+6] - segment[i+4];\n\t\ty = segment[i+7] - segment[i+5];\n\t\tresult[i+4] = Math.atan2(y, x);\n\t\tresult[i+5] = Math.sqrt(x * x + y * y);\n\t}\n\treturn result;\n}\n\n// takes a segment that was converted with cpCoordsToAngles() to have angles and lengths instead of coordinates for the control points, and converts it BACK into coordinates.\nexport function cpAnglesToCoords(segment, copy) {\n\tvar result = copy ? segment.slice(0) : segment,\n\t\tlength = segment.length,\n\t\trnd = 1000,\n\t\tangle, l, i, j;\n\tfor (i = 0; i < length; i+=6) {\n\t\tangle = segment[i+2];\n\t\tl = segment[i+3]; //length\n\t\tresult[i+2] = (((segment[i] + Math.cos(angle) * l) * rnd) | 0) / rnd;\n\t\tresult[i+3] = (((segment[i+1] + Math.sin(angle) * l) * rnd) | 0) / rnd;\n\t\tangle = segment[i+4];\n\t\tl = segment[i+5]; //length\n\t\tresult[i+4] = (((segment[i+6] - Math.cos(angle) * l) * rnd) | 0) / rnd;\n\t\tresult[i+5] = (((segment[i+7] - Math.sin(angle) * l) * rnd) | 0) / rnd;\n\t}\n\treturn result;\n}\n\n//adds an \"isSmooth\" array to each segment and populates it with a boolean value indicating whether or not it's smooth (the control points have basically the same slope). For any smooth control points, it converts the coordinates into angle (x, in radians) and length (y) and puts them into the same index value in a smoothData array.\nexport function populateSmoothData(rawPath) {\n\tlet j = rawPath.length,\n\t\tsmooth, segment, x, y, x2, y2, i, l, a, a2, isSmooth, smoothData;\n\twhile (--j > -1) {\n\t\tsegment = rawPath[j];\n\t\tisSmooth = segment.isSmooth = segment.isSmooth || [0, 0, 0, 0];\n\t\tsmoothData = segment.smoothData = segment.smoothData || [0, 0, 0, 0];\n\t\tisSmooth.length = 4;\n\t\tl = segment.length - 2;\n\t\tfor (i = 6; i < l; i += 6) {\n\t\t\tx = segment[i] - segment[i - 2];\n\t\t\ty = segment[i + 1] - segment[i - 1];\n\t\t\tx2 = segment[i + 2] - segment[i];\n\t\t\ty2 = segment[i + 3] - segment[i + 1];\n\t\t\ta = _atan2(y, x);\n\t\t\ta2 = _atan2(y2, x2);\n\t\t\tsmooth = (Math.abs(a - a2) < 0.09);\n\t\t\tif (smooth) {\n\t\t\t\tsmoothData[i - 2] = a;\n\t\t\t\tsmoothData[i + 2] = a2;\n\t\t\t\tsmoothData[i - 1] = _sqrt(x * x + y * y);\n\t\t\t\tsmoothData[i + 3] = _sqrt(x2 * x2 + y2 * y2);\n\t\t\t}\n\t\t\tisSmooth.push(smooth, smooth, 0, 0, smooth, smooth);\n\t\t}\n\t\t//if the first and last points are identical, check to see if there's a smooth transition. We must handle this a bit differently due to their positions in the array.\n\t\tif (segment[l] === segment[0] && segment[l+1] === segment[1]) {\n\t\t\tx = segment[0] - segment[l-2];\n\t\t\ty = segment[1] - segment[l-1];\n\t\t\tx2 = segment[2] - segment[0];\n\t\t\ty2 = segment[3] - segment[1];\n\t\t\ta = _atan2(y, x);\n\t\t\ta2 = _atan2(y2, x2);\n\t\t\tif (Math.abs(a - a2) < 0.09) {\n\t\t\t\tsmoothData[l-2] = a;\n\t\t\t\tsmoothData[2] = a2;\n\t\t\t\tsmoothData[l-1] = _sqrt(x * x + y * y);\n\t\t\t\tsmoothData[3] = _sqrt(x2 * x2 + y2 * y2);\n\t\t\t\tisSmooth[l-2] = isSmooth[l-1] = true; //don't change indexes 2 and 3 because we'll trigger everything from the END, and this will optimize file size a bit.\n\t\t\t}\n\t\t}\n\t}\n\treturn rawPath;\n}\nexport function pointToScreen(svgElement, point) {\n\tif (arguments.length < 2) { //by default, take the first set of coordinates in the path as the point\n\t\tlet rawPath = getRawPath(svgElement);\n\t\tpoint = svgElement.ownerSVGElement.createSVGPoint();\n\t\tpoint.x = rawPath[0][0];\n\t\tpoint.y = rawPath[0][1];\n\t}\n\treturn point.matrixTransform(svgElement.getScreenCTM());\n}\n\n*/","/*!\n * matrix 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 */\nvar _doc,\n    _win,\n    _docElement,\n    _body,\n    _divContainer,\n    _svgContainer,\n    _identityMatrix,\n    _gEl,\n    _transformProp = \"transform\",\n    _transformOriginProp = _transformProp + \"Origin\",\n    _hasOffsetBug,\n    _setDoc = function _setDoc(element) {\n  var doc = element.ownerDocument || element;\n\n  if (!(_transformProp in element.style) && \"msTransform\" in element.style) {\n    //to improve compatibility with old Microsoft browsers\n    _transformProp = \"msTransform\";\n    _transformOriginProp = _transformProp + \"Origin\";\n  }\n\n  while (doc.parentNode && (doc = doc.parentNode)) {}\n\n  _win = window;\n  _identityMatrix = new Matrix2D();\n\n  if (doc) {\n    _doc = doc;\n    _docElement = doc.documentElement;\n    _body = doc.body;\n    _gEl = _doc.createElementNS(\"http://www.w3.org/2000/svg\", \"g\"); // prevent any existing CSS from transforming it\n\n    _gEl.style.transform = \"none\"; // now test for the offset reporting bug. Use feature detection instead of browser sniffing to make things more bulletproof and future-proof. Hopefully Safari will fix their bug soon.\n\n    var d1 = doc.createElement(\"div\"),\n        d2 = doc.createElement(\"div\"),\n        root = doc && (doc.body || doc.firstElementChild);\n\n    if (root && root.appendChild) {\n      root.appendChild(d1);\n      d1.appendChild(d2);\n      d1.setAttribute(\"style\", \"position:static;transform:translate3d(0,0,1px)\");\n      _hasOffsetBug = d2.offsetParent !== d1;\n      root.removeChild(d1);\n    }\n  }\n\n  return doc;\n},\n    _forceNonZeroScale = function _forceNonZeroScale(e) {\n  // walks up the element's ancestors and finds any that had their scale set to 0 via GSAP, and changes them to 0.0001 to ensure that measurements work. Firefox has a bug that causes it to incorrectly report getBoundingClientRect() when scale is 0.\n  var a, cache;\n\n  while (e && e !== _body) {\n    cache = e._gsap;\n    cache && cache.uncache && cache.get(e, \"x\"); // force re-parsing of transforms if necessary\n\n    if (cache && !cache.scaleX && !cache.scaleY && cache.renderTransform) {\n      cache.scaleX = cache.scaleY = 1e-4;\n      cache.renderTransform(1, cache);\n      a ? a.push(cache) : a = [cache];\n    }\n\n    e = e.parentNode;\n  }\n\n  return a;\n},\n    // possible future addition: pass an element to _forceDisplay() and it'll walk up all its ancestors and make sure anything with display: none is set to display: block, and if there's no parentNode, it'll add it to the body. It returns an Array that you can then feed to _revertDisplay() to have it revert all the changes it made.\n// _forceDisplay = e => {\n// \tlet a = [],\n// \t\tparent;\n// \twhile (e && e !== _body) {\n// \t\tparent = e.parentNode;\n// \t\t(_win.getComputedStyle(e).display === \"none\" || !parent) && a.push(e, e.style.display, parent) && (e.style.display = \"block\");\n// \t\tparent || _body.appendChild(e);\n// \t\te = parent;\n// \t}\n// \treturn a;\n// },\n// _revertDisplay = a => {\n// \tfor (let i = 0; i < a.length; i+=3) {\n// \t\ta[i+1] ? (a[i].style.display = a[i+1]) : a[i].style.removeProperty(\"display\");\n// \t\ta[i+2] || a[i].parentNode.removeChild(a[i]);\n// \t}\n// },\n_svgTemps = [],\n    //we create 3 elements for SVG, and 3 for other DOM elements and cache them for performance reasons. They get nested in _divContainer and _svgContainer so that just one element is added to the DOM on each successive attempt. Again, performance is key.\n_divTemps = [],\n    _getDocScrollTop = function _getDocScrollTop() {\n  return _win.pageYOffset || _doc.scrollTop || _docElement.scrollTop || _body.scrollTop || 0;\n},\n    _getDocScrollLeft = function _getDocScrollLeft() {\n  return _win.pageXOffset || _doc.scrollLeft || _docElement.scrollLeft || _body.scrollLeft || 0;\n},\n    _svgOwner = function _svgOwner(element) {\n  return element.ownerSVGElement || ((element.tagName + \"\").toLowerCase() === \"svg\" ? element : null);\n},\n    _isFixed = function _isFixed(element) {\n  if (_win.getComputedStyle(element).position === \"fixed\") {\n    return true;\n  }\n\n  element = element.parentNode;\n\n  if (element && element.nodeType === 1) {\n    // avoid document fragments which will throw an error.\n    return _isFixed(element);\n  }\n},\n    _createSibling = function _createSibling(element, i) {\n  if (element.parentNode && (_doc || _setDoc(element))) {\n    var svg = _svgOwner(element),\n        ns = svg ? svg.getAttribute(\"xmlns\") || \"http://www.w3.org/2000/svg\" : \"http://www.w3.org/1999/xhtml\",\n        type = svg ? i ? \"rect\" : \"g\" : \"div\",\n        x = i !== 2 ? 0 : 100,\n        y = i === 3 ? 100 : 0,\n        css = \"position:absolute;display:block;pointer-events:none;margin:0;padding:0;\",\n        e = _doc.createElementNS ? _doc.createElementNS(ns.replace(/^https/, \"http\"), type) : _doc.createElement(type);\n\n    if (i) {\n      if (!svg) {\n        if (!_divContainer) {\n          _divContainer = _createSibling(element);\n          _divContainer.style.cssText = css;\n        }\n\n        e.style.cssText = css + \"width:0.1px;height:0.1px;top:\" + y + \"px;left:\" + x + \"px\";\n\n        _divContainer.appendChild(e);\n      } else {\n        _svgContainer || (_svgContainer = _createSibling(element));\n        e.setAttribute(\"width\", 0.01);\n        e.setAttribute(\"height\", 0.01);\n        e.setAttribute(\"transform\", \"translate(\" + x + \",\" + y + \")\");\n\n        _svgContainer.appendChild(e);\n      }\n    }\n\n    return e;\n  }\n\n  throw \"Need document and parent.\";\n},\n    _consolidate = function _consolidate(m) {\n  // replaces SVGTransformList.consolidate() because a bug in Firefox causes it to break pointer events. See https://gsap.com/forums/topic/23248-touch-is-not-working-on-draggable-in-firefox-windows-v324/?tab=comments#comment-109800\n  var c = new Matrix2D(),\n      i = 0;\n\n  for (; i < m.numberOfItems; i++) {\n    c.multiply(m.getItem(i).matrix);\n  }\n\n  return c;\n},\n    _getCTM = function _getCTM(svg) {\n  var m = svg.getCTM(),\n      transform;\n\n  if (!m) {\n    // Firefox returns null for getCTM() on root <svg> elements, so this is a workaround using a <g> that we temporarily append.\n    transform = svg.style[_transformProp];\n    svg.style[_transformProp] = \"none\"; // a bug in Firefox causes css transforms to contaminate the getCTM()\n\n    svg.appendChild(_gEl);\n    m = _gEl.getCTM();\n    svg.removeChild(_gEl);\n    transform ? svg.style[_transformProp] = transform : svg.style.removeProperty(_transformProp.replace(/([A-Z])/g, \"-$1\").toLowerCase());\n  }\n\n  return m || _identityMatrix.clone(); // Firefox will still return null if the <svg> has a width/height of 0 in the browser.\n},\n    _placeSiblings = function _placeSiblings(element, adjustGOffset) {\n  var svg = _svgOwner(element),\n      isRootSVG = element === svg,\n      siblings = svg ? _svgTemps : _divTemps,\n      parent = element.parentNode,\n      container,\n      m,\n      b,\n      x,\n      y,\n      cs;\n\n  if (element === _win) {\n    return element;\n  }\n\n  siblings.length || siblings.push(_createSibling(element, 1), _createSibling(element, 2), _createSibling(element, 3));\n  container = svg ? _svgContainer : _divContainer;\n\n  if (svg) {\n    if (isRootSVG) {\n      b = _getCTM(element);\n      x = -b.e / b.a;\n      y = -b.f / b.d;\n      m = _identityMatrix;\n    } else if (element.getBBox) {\n      b = element.getBBox();\n      m = element.transform ? element.transform.baseVal : {}; // IE11 doesn't follow the spec.\n\n      m = !m.numberOfItems ? _identityMatrix : m.numberOfItems > 1 ? _consolidate(m) : m.getItem(0).matrix; // don't call m.consolidate().matrix because a bug in Firefox makes pointer events not work when consolidate() is called on the same tick as getBoundingClientRect()! See https://gsap.com/forums/topic/23248-touch-is-not-working-on-draggable-in-firefox-windows-v324/?tab=comments#comment-109800\n\n      x = m.a * b.x + m.c * b.y;\n      y = m.b * b.x + m.d * b.y;\n    } else {\n      // may be a <mask> which has no getBBox() so just use defaults instead of throwing errors.\n      m = new Matrix2D();\n      x = y = 0;\n    }\n\n    if (adjustGOffset && element.tagName.toLowerCase() === \"g\") {\n      x = y = 0;\n    }\n\n    (isRootSVG ? svg : parent).appendChild(container);\n    container.setAttribute(\"transform\", \"matrix(\" + m.a + \",\" + m.b + \",\" + m.c + \",\" + m.d + \",\" + (m.e + x) + \",\" + (m.f + y) + \")\");\n  } else {\n    x = y = 0;\n\n    if (_hasOffsetBug) {\n      // some browsers (like Safari) have a bug that causes them to misreport offset values. When an ancestor element has a transform applied, it's supposed to treat it as if it's position: relative (new context). Safari botches this, so we need to find the closest ancestor (between the element and its offsetParent) that has a transform applied and if one is found, grab its offsetTop/Left and subtract them to compensate.\n      m = element.offsetParent;\n      b = element;\n\n      while (b && (b = b.parentNode) && b !== m && b.parentNode) {\n        if ((_win.getComputedStyle(b)[_transformProp] + \"\").length > 4) {\n          x = b.offsetLeft;\n          y = b.offsetTop;\n          b = 0;\n        }\n      }\n    }\n\n    cs = _win.getComputedStyle(element);\n\n    if (cs.position !== \"absolute\" && cs.position !== \"fixed\") {\n      m = element.offsetParent;\n\n      while (parent && parent !== m) {\n        // if there's an ancestor element between the element and its offsetParent that's scrolled, we must factor that in.\n        x += parent.scrollLeft || 0;\n        y += parent.scrollTop || 0;\n        parent = parent.parentNode;\n      }\n    }\n\n    b = container.style;\n    b.top = element.offsetTop - y + \"px\";\n    b.left = element.offsetLeft - x + \"px\";\n    b[_transformProp] = cs[_transformProp];\n    b[_transformOriginProp] = cs[_transformOriginProp]; // b.border = m.border;\n    // b.borderLeftStyle = m.borderLeftStyle;\n    // b.borderTopStyle = m.borderTopStyle;\n    // b.borderLeftWidth = m.borderLeftWidth;\n    // b.borderTopWidth = m.borderTopWidth;\n\n    b.position = cs.position === \"fixed\" ? \"fixed\" : \"absolute\";\n    element.parentNode.appendChild(container);\n  }\n\n  return container;\n},\n    _setMatrix = function _setMatrix(m, a, b, c, d, e, f) {\n  m.a = a;\n  m.b = b;\n  m.c = c;\n  m.d = d;\n  m.e = e;\n  m.f = f;\n  return m;\n};\n\nexport var Matrix2D = /*#__PURE__*/function () {\n  function Matrix2D(a, b, c, d, e, f) {\n    if (a === void 0) {\n      a = 1;\n    }\n\n    if (b === void 0) {\n      b = 0;\n    }\n\n    if (c === void 0) {\n      c = 0;\n    }\n\n    if (d === void 0) {\n      d = 1;\n    }\n\n    if (e === void 0) {\n      e = 0;\n    }\n\n    if (f === void 0) {\n      f = 0;\n    }\n\n    _setMatrix(this, a, b, c, d, e, f);\n  }\n\n  var _proto = Matrix2D.prototype;\n\n  _proto.inverse = function inverse() {\n    var a = this.a,\n        b = this.b,\n        c = this.c,\n        d = this.d,\n        e = this.e,\n        f = this.f,\n        determinant = a * d - b * c || 1e-10;\n    return _setMatrix(this, d / determinant, -b / determinant, -c / determinant, a / determinant, (c * f - d * e) / determinant, -(a * f - b * e) / determinant);\n  };\n\n  _proto.multiply = function multiply(matrix) {\n    var a = this.a,\n        b = this.b,\n        c = this.c,\n        d = this.d,\n        e = this.e,\n        f = this.f,\n        a2 = matrix.a,\n        b2 = matrix.c,\n        c2 = matrix.b,\n        d2 = matrix.d,\n        e2 = matrix.e,\n        f2 = matrix.f;\n    return _setMatrix(this, a2 * a + c2 * c, a2 * b + c2 * d, b2 * a + d2 * c, b2 * b + d2 * d, e + e2 * a + f2 * c, f + e2 * b + f2 * d);\n  };\n\n  _proto.clone = function clone() {\n    return new Matrix2D(this.a, this.b, this.c, this.d, this.e, this.f);\n  };\n\n  _proto.equals = function equals(matrix) {\n    var a = this.a,\n        b = this.b,\n        c = this.c,\n        d = this.d,\n        e = this.e,\n        f = this.f;\n    return a === matrix.a && b === matrix.b && c === matrix.c && d === matrix.d && e === matrix.e && f === matrix.f;\n  };\n\n  _proto.apply = function apply(point, decoratee) {\n    if (decoratee === void 0) {\n      decoratee = {};\n    }\n\n    var x = point.x,\n        y = point.y,\n        a = this.a,\n        b = this.b,\n        c = this.c,\n        d = this.d,\n        e = this.e,\n        f = this.f;\n    decoratee.x = x * a + y * c + e || 0;\n    decoratee.y = x * b + y * d + f || 0;\n    return decoratee;\n  };\n\n  return Matrix2D;\n}(); // Feed in an element and it'll return a 2D matrix (optionally inverted) so that you can translate between coordinate spaces.\n// Inverting lets you translate a global point into a local coordinate space. No inverting lets you go the other way.\n// We needed this to work around various browser bugs, like Firefox doesn't accurately report getScreenCTM() when there\n// are transforms applied to ancestor elements.\n// The matrix math to convert any x/y coordinate is as follows, which is wrapped in a convenient apply() method of Matrix2D above:\n//     tx = m.a * x + m.c * y + m.e\n//     ty = m.b * x + m.d * y + m.f\n\nexport function getGlobalMatrix(element, inverse, adjustGOffset, includeScrollInFixed) {\n  // adjustGOffset is typically used only when grabbing an element's PARENT's global matrix, and it ignores the x/y offset of any SVG <g> elements because they behave in a special way.\n  if (!element || !element.parentNode || (_doc || _setDoc(element)).documentElement === element) {\n    return new Matrix2D();\n  }\n\n  var zeroScales = _forceNonZeroScale(element),\n      svg = _svgOwner(element),\n      temps = svg ? _svgTemps : _divTemps,\n      container = _placeSiblings(element, adjustGOffset),\n      b1 = temps[0].getBoundingClientRect(),\n      b2 = temps[1].getBoundingClientRect(),\n      b3 = temps[2].getBoundingClientRect(),\n      parent = container.parentNode,\n      isFixed = !includeScrollInFixed && _isFixed(element),\n      m = new Matrix2D((b2.left - b1.left) / 100, (b2.top - b1.top) / 100, (b3.left - b1.left) / 100, (b3.top - b1.top) / 100, b1.left + (isFixed ? 0 : _getDocScrollLeft()), b1.top + (isFixed ? 0 : _getDocScrollTop()));\n\n  parent.removeChild(container);\n\n  if (zeroScales) {\n    b1 = zeroScales.length;\n\n    while (b1--) {\n      b2 = zeroScales[b1];\n      b2.scaleX = b2.scaleY = 0;\n      b2.renderTransform(1, b2);\n    }\n  }\n\n  return inverse ? m.inverse() : m;\n}\nexport { _getDocScrollTop, _getDocScrollLeft, _setDoc, _isFixed, _getCTM }; // export function getMatrix(element) {\n// \t_doc || _setDoc(element);\n// \tlet m = (_win.getComputedStyle(element)[_transformProp] + \"\").substr(7).match(/[-.]*\\d+[.e\\-+]*\\d*[e\\-\\+]*\\d*/g),\n// \t\tis2D = m && m.length === 6;\n// \treturn !m || m.length < 6 ? new Matrix2D() : new Matrix2D(+m[0], +m[1], +m[is2D ? 2 : 4], +m[is2D ? 3 : 5], +m[is2D ? 4 : 12], +m[is2D ? 5 : 13]);\n// }","/*!\n * MotionPathPlugin 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 { getRawPath, cacheRawPathMeasurements, getPositionOnPath, pointsToSegment, flatPointsToSegment, sliceRawPath, stringToRawPath, rawPathToString, transformRawPath, convertToPath as _convertToPath } from \"./utils/paths.js\";\nimport { getGlobalMatrix } from \"./utils/matrix.js\";\n\nvar _xProps = \"x,translateX,left,marginLeft,xPercent\".split(\",\"),\n    _yProps = \"y,translateY,top,marginTop,yPercent\".split(\",\"),\n    _DEG2RAD = Math.PI / 180,\n    gsap,\n    PropTween,\n    _getUnit,\n    _toArray,\n    _getStyleSaver,\n    _reverting,\n    _getGSAP = function _getGSAP() {\n  return gsap || typeof window !== \"undefined\" && (gsap = window.gsap) && gsap.registerPlugin && gsap;\n},\n    _populateSegmentFromArray = function _populateSegmentFromArray(segment, values, property, mode) {\n  //mode: 0 = x but don't fill y yet, 1 = y, 2 = x and fill y with 0.\n  var l = values.length,\n      si = mode === 2 ? 0 : mode,\n      i = 0,\n      v;\n\n  for (; i < l; i++) {\n    segment[si] = v = parseFloat(values[i][property]);\n    mode === 2 && (segment[si + 1] = 0);\n    si += 2;\n  }\n\n  return segment;\n},\n    _getPropNum = function _getPropNum(target, prop, unit) {\n  return parseFloat(target._gsap.get(target, prop, unit || \"px\")) || 0;\n},\n    _relativize = function _relativize(segment) {\n  var x = segment[0],\n      y = segment[1],\n      i;\n\n  for (i = 2; i < segment.length; i += 2) {\n    x = segment[i] += x;\n    y = segment[i + 1] += y;\n  }\n},\n    // feed in an array of quadratic bezier points like [{x: 0, y: 0}, ...] and it'll convert it to cubic bezier\n// _quadToCubic = points => {\n// \tlet cubic = [],\n// \t\tl = points.length - 1,\n// \t\ti = 1,\n// \t\ta, b, c;\n// \tfor (; i < l; i+=2) {\n// \t\ta = points[i-1];\n// \t\tb = points[i];\n// \t\tc = points[i+1];\n// \t\tcubic.push(a, {x: (2 * b.x + a.x) / 3, y: (2 * b.y + a.y) / 3}, {x: (2 * b.x + c.x) / 3, y: (2 * b.y + c.y) / 3});\n// \t}\n// \tcubic.push(points[l]);\n// \treturn cubic;\n// },\n_segmentToRawPath = function _segmentToRawPath(plugin, segment, target, x, y, slicer, vars, unitX, unitY) {\n  if (vars.type === \"cubic\") {\n    segment = [segment];\n  } else {\n    vars.fromCurrent !== false && segment.unshift(_getPropNum(target, x, unitX), y ? _getPropNum(target, y, unitY) : 0);\n    vars.relative && _relativize(segment);\n    var pointFunc = y ? pointsToSegment : flatPointsToSegment;\n    segment = [pointFunc(segment, vars.curviness)];\n  }\n\n  segment = slicer(_align(segment, target, vars));\n\n  _addDimensionalPropTween(plugin, target, x, segment, \"x\", unitX);\n\n  y && _addDimensionalPropTween(plugin, target, y, segment, \"y\", unitY);\n  return cacheRawPathMeasurements(segment, vars.resolution || (vars.curviness === 0 ? 20 : 12)); //when curviness is 0, it creates control points right on top of the anchors which makes it more sensitive to resolution, thus we change the default accordingly.\n},\n    _emptyFunc = function _emptyFunc(v) {\n  return v;\n},\n    _numExp = /[-+\\.]*\\d+\\.?(?:e-|e\\+)?\\d*/g,\n    _originToPoint = function _originToPoint(element, origin, parentMatrix) {\n  // origin is an array of normalized values (0-1) in relation to the width/height, so [0.5, 0.5] would be the center. It can also be \"auto\" in which case it will be the top left unless it's a <path>, when it will start at the beginning of the path itself.\n  var m = getGlobalMatrix(element),\n      x = 0,\n      y = 0,\n      svg;\n\n  if ((element.tagName + \"\").toLowerCase() === \"svg\") {\n    svg = element.viewBox.baseVal;\n    svg.width || (svg = {\n      width: +element.getAttribute(\"width\"),\n      height: +element.getAttribute(\"height\")\n    });\n  } else {\n    svg = origin && element.getBBox && element.getBBox();\n  }\n\n  if (origin && origin !== \"auto\") {\n    x = origin.push ? origin[0] * (svg ? svg.width : element.offsetWidth || 0) : origin.x;\n    y = origin.push ? origin[1] * (svg ? svg.height : element.offsetHeight || 0) : origin.y;\n  }\n\n  return parentMatrix.apply(x || y ? m.apply({\n    x: x,\n    y: y\n  }) : {\n    x: m.e,\n    y: m.f\n  });\n},\n    _getAlignMatrix = function _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin) {\n  var parentMatrix = getGlobalMatrix(fromElement.parentNode, true, true),\n      m = parentMatrix.clone().multiply(getGlobalMatrix(toElement)),\n      fromPoint = _originToPoint(fromElement, fromOrigin, parentMatrix),\n      _originToPoint2 = _originToPoint(toElement, toOrigin, parentMatrix),\n      x = _originToPoint2.x,\n      y = _originToPoint2.y,\n      p;\n\n  m.e = m.f = 0;\n\n  if (toOrigin === \"auto\" && toElement.getTotalLength && toElement.tagName.toLowerCase() === \"path\") {\n    p = toElement.getAttribute(\"d\").match(_numExp) || [];\n    p = m.apply({\n      x: +p[0],\n      y: +p[1]\n    });\n    x += p.x;\n    y += p.y;\n  } //if (p || (toElement.getBBox && fromElement.getBBox && toElement.ownerSVGElement === fromElement.ownerSVGElement)) {\n\n\n  if (p) {\n    p = m.apply(toElement.getBBox());\n    x -= p.x;\n    y -= p.y;\n  }\n\n  m.e = x - fromPoint.x;\n  m.f = y - fromPoint.y;\n  return m;\n},\n    _align = function _align(rawPath, target, _ref) {\n  var align = _ref.align,\n      matrix = _ref.matrix,\n      offsetX = _ref.offsetX,\n      offsetY = _ref.offsetY,\n      alignOrigin = _ref.alignOrigin;\n\n  var x = rawPath[0][0],\n      y = rawPath[0][1],\n      curX = _getPropNum(target, \"x\"),\n      curY = _getPropNum(target, \"y\"),\n      alignTarget,\n      m,\n      p;\n\n  if (!rawPath || !rawPath.length) {\n    return getRawPath(\"M0,0L0,0\");\n  }\n\n  if (align) {\n    if (align === \"self\" || (alignTarget = _toArray(align)[0] || target) === target) {\n      transformRawPath(rawPath, 1, 0, 0, 1, curX - x, curY - y);\n    } else {\n      if (alignOrigin && alignOrigin[2] !== false) {\n        gsap.set(target, {\n          transformOrigin: alignOrigin[0] * 100 + \"% \" + alignOrigin[1] * 100 + \"%\"\n        });\n      } else {\n        alignOrigin = [_getPropNum(target, \"xPercent\") / -100, _getPropNum(target, \"yPercent\") / -100];\n      }\n\n      m = _getAlignMatrix(target, alignTarget, alignOrigin, \"auto\");\n      p = m.apply({\n        x: x,\n        y: y\n      });\n      transformRawPath(rawPath, m.a, m.b, m.c, m.d, curX + m.e - (p.x - m.e), curY + m.f - (p.y - m.f));\n    }\n  }\n\n  if (matrix) {\n    transformRawPath(rawPath, matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);\n  } else if (offsetX || offsetY) {\n    transformRawPath(rawPath, 1, 0, 0, 1, offsetX || 0, offsetY || 0);\n  }\n\n  return rawPath;\n},\n    _addDimensionalPropTween = function _addDimensionalPropTween(plugin, target, property, rawPath, pathProperty, forceUnit) {\n  var cache = target._gsap,\n      harness = cache.harness,\n      alias = harness && harness.aliases && harness.aliases[property],\n      prop = alias && alias.indexOf(\",\") < 0 ? alias : property,\n      pt = plugin._pt = new PropTween(plugin._pt, target, prop, 0, 0, _emptyFunc, 0, cache.set(target, prop, plugin));\n  pt.u = _getUnit(cache.get(target, prop, forceUnit)) || 0;\n  pt.path = rawPath;\n  pt.pp = pathProperty;\n\n  plugin._props.push(prop);\n},\n    _sliceModifier = function _sliceModifier(start, end) {\n  return function (rawPath) {\n    return start || end !== 1 ? sliceRawPath(rawPath, start, end) : rawPath;\n  };\n};\n\nexport var MotionPathPlugin = {\n  version: \"3.12.5\",\n  name: \"motionPath\",\n  register: function register(core, Plugin, propTween) {\n    gsap = core;\n    _getUnit = gsap.utils.getUnit;\n    _toArray = gsap.utils.toArray;\n    _getStyleSaver = gsap.core.getStyleSaver;\n\n    _reverting = gsap.core.reverting || function () {};\n\n    PropTween = propTween;\n  },\n  init: function init(target, vars, tween) {\n    if (!gsap) {\n      console.warn(\"Please gsap.registerPlugin(MotionPathPlugin)\");\n      return false;\n    }\n\n    if (!(typeof vars === \"object\" && !vars.style) || !vars.path) {\n      vars = {\n        path: vars\n      };\n    }\n\n    var rawPaths = [],\n        _vars = vars,\n        path = _vars.path,\n        autoRotate = _vars.autoRotate,\n        unitX = _vars.unitX,\n        unitY = _vars.unitY,\n        x = _vars.x,\n        y = _vars.y,\n        firstObj = path[0],\n        slicer = _sliceModifier(vars.start, \"end\" in vars ? vars.end : 1),\n        rawPath,\n        p;\n\n    this.rawPaths = rawPaths;\n    this.target = target;\n    this.tween = tween;\n    this.styles = _getStyleSaver && _getStyleSaver(target, \"transform\");\n\n    if (this.rotate = autoRotate || autoRotate === 0) {\n      //get the rotational data FIRST so that the setTransform() method is called in the correct order in the render() loop - rotation gets set last.\n      this.rOffset = parseFloat(autoRotate) || 0;\n      this.radians = !!vars.useRadians;\n      this.rProp = vars.rotation || \"rotation\"; // rotation property\n\n      this.rSet = target._gsap.set(target, this.rProp, this); // rotation setter\n\n      this.ru = _getUnit(target._gsap.get(target, this.rProp)) || 0; // rotation units\n    }\n\n    if (Array.isArray(path) && !(\"closed\" in path) && typeof firstObj !== \"number\") {\n      for (p in firstObj) {\n        if (!x && ~_xProps.indexOf(p)) {\n          x = p;\n        } else if (!y && ~_yProps.indexOf(p)) {\n          y = p;\n        }\n      }\n\n      if (x && y) {\n        //correlated values\n        rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray(_populateSegmentFromArray([], path, x, 0), path, y, 1), target, x, y, slicer, vars, unitX || _getUnit(path[0][x]), unitY || _getUnit(path[0][y])));\n      } else {\n        x = y = 0;\n      }\n\n      for (p in firstObj) {\n        p !== x && p !== y && rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray([], path, p, 2), target, p, 0, slicer, vars, _getUnit(path[0][p])));\n      }\n    } else {\n      rawPath = slicer(_align(getRawPath(vars.path), target, vars));\n      cacheRawPathMeasurements(rawPath, vars.resolution);\n      rawPaths.push(rawPath);\n\n      _addDimensionalPropTween(this, target, vars.x || \"x\", rawPath, \"x\", vars.unitX || \"px\");\n\n      _addDimensionalPropTween(this, target, vars.y || \"y\", rawPath, \"y\", vars.unitY || \"px\");\n    }\n  },\n  render: function render(ratio, data) {\n    var rawPaths = data.rawPaths,\n        i = rawPaths.length,\n        pt = data._pt;\n\n    if (data.tween._time || !_reverting()) {\n      if (ratio > 1) {\n        ratio = 1;\n      } else if (ratio < 0) {\n        ratio = 0;\n      }\n\n      while (i--) {\n        getPositionOnPath(rawPaths[i], ratio, !i && data.rotate, rawPaths[i]);\n      }\n\n      while (pt) {\n        pt.set(pt.t, pt.p, pt.path[pt.pp] + pt.u, pt.d, ratio);\n        pt = pt._next;\n      }\n\n      data.rotate && data.rSet(data.target, data.rProp, rawPaths[0].angle * (data.radians ? _DEG2RAD : 1) + data.rOffset + data.ru, data, ratio);\n    } else {\n      data.styles.revert();\n    }\n  },\n  getLength: function getLength(path) {\n    return cacheRawPathMeasurements(getRawPath(path)).totalLength;\n  },\n  sliceRawPath: sliceRawPath,\n  getRawPath: getRawPath,\n  pointsToSegment: pointsToSegment,\n  stringToRawPath: stringToRawPath,\n  rawPathToString: rawPathToString,\n  transformRawPath: transformRawPath,\n  getGlobalMatrix: getGlobalMatrix,\n  getPositionOnPath: getPositionOnPath,\n  cacheRawPathMeasurements: cacheRawPathMeasurements,\n  convertToPath: function convertToPath(targets, swap) {\n    return _toArray(targets).map(function (target) {\n      return _convertToPath(target, swap !== false);\n    });\n  },\n  convertCoordinates: function convertCoordinates(fromElement, toElement, point) {\n    var m = getGlobalMatrix(toElement, true, true).multiply(getGlobalMatrix(fromElement));\n    return point ? m.apply(point) : m;\n  },\n  getAlignMatrix: _getAlignMatrix,\n  getRelativePosition: function getRelativePosition(fromElement, toElement, fromOrigin, toOrigin) {\n    var m = _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin);\n\n    return {\n      x: m.e,\n      y: m.f\n    };\n  },\n  arrayToRawPath: function arrayToRawPath(value, vars) {\n    vars = vars || {};\n\n    var segment = _populateSegmentFromArray(_populateSegmentFromArray([], value, vars.x || \"x\", 0), value, vars.y || \"y\", 1);\n\n    vars.relative && _relativize(segment);\n    return [vars.type === \"cubic\" ? segment : pointsToSegment(segment, vars.curviness)];\n  }\n};\n_getGSAP() && gsap.registerPlugin(MotionPathPlugin);\nexport { MotionPathPlugin as default };","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 };"],"names":["_svgPathExp","_numbersExp","_scientific","_selectorExp","_DEG2RAD","Math","PI","_RAD2DEG","_sin","sin","_cos","cos","_abs","abs","_sqrt","sqrt","_atan2","atan2","_largeNum","_isString","value","_isNumber","_temp","_temp2","_roundingNum","_wrapProgress","progress","round","_round","_roundPrecise","_splitSegment","rawPath","segIndex","i","t","segment","shift","subdivideSegment","length","splice","slice","_getSampleIndex","samples","l","_copyMetaData","source","copy","totalLength","lookup","minLength","resolution","totalPoints","_appendOrMerge","index","prevSeg","concat","getRawPath","e","test","document","querySelector","getAttribute","_gsPath","_dirty","stringToRawPath","console","warn","reverseSegment","y","reverse","reversed","_typeAttrs","rect","circle","ellipse","line","getRotationAtBezierT","x","a","b","c","sliceRawPath","start","end","loops","max","path","copyRawPath","skipOuter","_reverseRawPath","offset","min","cacheRawPathMeasurements","wrapsBehind","sShift","eShift","totalSegments","j","wrap","s","getProgressData","eSeg","sSeg","eSegIndex","sSegIndex","ei","si","sameSegment","sameBezier","angle","push","measureSegment","startIndex","bezierQty","x4","x3","x2","xd","xd1","y4","y3","y2","yd","yd1","inv","lengthIndex","segLength","inc","endIndex","x1","y1","samplesIndex","prevLength","pathLength","points","ax","ay","cp1x","cp1y","cp2x","cp2y","x1a","y1a","x2a","y2a","decoratee","pushToNextIfAtEnd","getPositionOnPath","includeAngle","point","result","transformRawPath","d","tx","ty","arcToSegment","lastX","lastY","rx","ry","largeArcFlag","sweepFlag","angleRad","cosAngle","sinAngle","TWOPI","dx2","dy2","x1_sq","y1_sq","radiiCheck","rx_sq","ry_sq","sq","coef","cx1","cy1","cx","cy","ux","uy","vx","vy","temp","angleStart","acos","angleExtent","isNaN","segments","ceil","angleIncrement","controlLength","ma","mb","mc","md","command","isRelative","startX","startY","difX","difY","beziers","prevCommand","flag1","flag2","replace","m","n","match","relativeX","relativeY","twoThirds","elements","errorMessage","sx","sy","ex","ey","log","toUpperCase","closed","substr","charAt","pop","flatPointsToSegment","curviness","pointsToSegment","prevX","prevY","dx1","dy1","r1","r2","tl","mx1","mx2","mxm","my1","my2","mym","nextX","nextY","unshift","pow","rawPathToString","sl","_doc","_win","_docElement","_body","_divContainer","_svgContainer","_identityMatrix","_gEl","_hasOffsetBug","_transformProp","_transformOriginProp","_setDoc","element","doc","ownerDocument","style","parentNode","window","Matrix2D","documentElement","body","createElementNS","transform","d1","createElement","d2","root","firstElementChild","appendChild","setAttribute","offsetParent","removeChild","_svgTemps","_divTemps","_svgOwner","ownerSVGElement","tagName","toLowerCase","_isFixed","getComputedStyle","position","nodeType","_createSibling","svg","ns","type","css","cssText","_setMatrix","f","this","_proto","prototype","inverse","determinant","multiply","matrix","a2","b2","c2","e2","f2","clone","equals","apply","getGlobalMatrix","adjustGOffset","includeScrollInFixed","zeroScales","cache","_gsap","uncache","get","scaleX","scaleY","renderTransform","_forceNonZeroScale","temps","container","cs","isRootSVG","siblings","parent","getCTM","removeProperty","_getCTM","getBBox","baseVal","numberOfItems","getItem","_consolidate","offsetLeft","offsetTop","scrollLeft","scrollTop","top","left","_placeSiblings","b1","getBoundingClientRect","b3","isFixed","pageXOffset","pageYOffset","gsap","PropTween","_getUnit","_toArray","_getStyleSaver","_reverting","_xProps","split","_yProps","_populateSegmentFromArray","values","property","mode","parseFloat","_getPropNum","target","prop","unit","_relativize","_segmentToRawPath","plugin","slicer","vars","unitX","unitY","fromCurrent","relative","_align","_addDimensionalPropTween","_emptyFunc","v","_numExp","_originToPoint","origin","parentMatrix","viewBox","width","height","offsetWidth","offsetHeight","_getAlignMatrix","fromElement","toElement","fromOrigin","toOrigin","p","fromPoint","_originToPoint2","getTotalLength","_ref","alignTarget","align","offsetX","offsetY","alignOrigin","curX","curY","set","transformOrigin","pathProperty","forceUnit","harness","alias","aliases","indexOf","pt","_pt","u","pp","_props","MotionPathPlugin","version","name","register","core","Plugin","propTween","utils","getUnit","toArray","getStyleSaver","reverting","init","tween","rawPaths","_vars","autoRotate","firstObj","styles","rotate","rOffset","radians","useRadians","rProp","rotation","rSet","ru","Array","isArray","render","ratio","data","_time","_next","revert","getLength","convertToPath","targets","swap","map","r","rcirc","rycirc","w","h","x5","x6","y5","y6","attr","circ","ignore","call","attributes","nodeName","setAttributeNS","nodeValue","_createPath","attrs","props","obj","_attrToObj","join","_gsRawPath","insertBefore","convertCoordinates","getAlignMatrix","getRelativePosition","arrayToRawPath","registerPlugin","_defineProperties","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_coreInitted","_docEl","_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","_horizontal","p2","os","os2","sc","arguments","scrollTo","_vertical","op","_getTarget","self","_ctx","selector","config","nullTargetWarn","_getScrollFunc","scrollingElement","prev","smooth","getProperty","_getVelocityProp","minTimeRefresh","useDelta","v1","v2","t1","t2","dropToZeroTime","update","force","reset","getVelocity","latestValue","tOld","vOld","_getEvent","preventDefault","_gsapAllow","changedTouches","_getAbsoluteMax","_setScrollTrigger","scrollers","proxies","globals","bridge","_initCore","clamp","context","Observer","isTouch","matchMedia","matches","navigator","maxTouchPoints","msMaxTouchPoints","eventTypes","setTimeout","Constructor","protoProps","tolerance","dragMinimum","lineHeight","debounce","onStop","onStopDelay","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","deltaX","deltaY","onClickTime","clickCapture","_ignoreCheck","isPointerOrTouch","pointerType","dx","dy","changedX","changedY","onDelta","_vx","_vy","requestAnimationFrame","onTouchOrPointerDelta","_onDrag","clientX","clientY","isDragging","_onPress","button","pause","_onRelease","isTrackingDrag","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","create","getAll","getById","_resizeDelay","_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","_keepClamp","_rafBugFix","_pointerDownHandler","_pointerUpHandler","_passThrough","_windowExists","_getViewportDimension","dimensionProperty","_getBoundsFunc","_winOffsets","innerWidth","_getBounds","_maxScroll","_ref2","_iterateAutoRefresh","events","_isFunction","_isObject","_endAnimation","animation","_callback","enabled","add","totalTime","callbackAnimation","_left","_right","_bottom","_width","_height","_Right","_Left","_Top","_Bottom","_padding","_margin","_Width","_Height","_px","_getComputedStyle","_setDefaults","defaults","withoutTransforms","to","xPercent","yPercent","rotationX","rotationY","scale","skewX","skewY","bounds","_getSize","_ref3","_getLabelRatioArray","timeline","labels","duration","_snapDirectional","snapIncrementOrArray","snap","sort","direction","threshold","snapped","_multiListener","types","callback","forEach","nonPassive","_wheelListener","scrollFunc","wheelHandler","_markerDefaults","startColor","endColor","indent","fontSize","fontWeight","_defaults","toggleActions","anticipatePin","_keywords","center","bottom","right","_offsetToPx","size","eqIndex","_createMarker","_ref4","matchWidthEl","containerAnimation","useFixedPosition","isScroller","isStart","color","_isStart","innerText","children","_offset","_positionMarker","marker","flipped","display","side","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","horizontal","original","adjustPinSpacing","scroller","_dir","endClamp","_endClamp","startClamp","_startClamp","setPositions","onRefresh","_lastScroll","_direction","isUpdating","time","recordVelocity","scroll","_propNamesToCopy","_stateProps","_swapPinIn","spacer","spacerState","swappedIn","spacerStyle","pinStyle","flexBasis","overflow","boxSizing","_setState","_capsExp","state","getCache","_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","change","pinOriginalState","pinActiveState","pinState","pinGetter","pinSetter","pinStart","pinChange","spacingStart","markerStartSetter","pinMoves","markerEndSetter","snap1","snap2","scrubTween","scrubSmooth","snapDurClamp","snapDelayedCall","prevScroll","prevAnimProgress","caMarkerSetter","customRevertReturn","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","endValue","endScroll","velocity","naturalEnd","inertia","_snap","onStart","_onInterrupt","_onComplete","resetTo","_tTime","_tDur","stRevert","className","nativeElement","spacerIsNative","classList","force3D","quickSetter","content","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","_pinPush","normalize","_pinOffset","omitOffsets","_copyState","endAnimation","labelToScroll","label","getTrailing","forceFake","toggleState","action","stateChanged","toggled","isAtMax","isTakingAction","clipped","_dp","_start","newStart","newEnd","keepClamp","_change","amount","allowAnimation","onKill","updateFunc","_queueRefreshAll","clearInterval","suppressOverwrites","userAgent","mm","bodyStyle","border","borderTopStyle","AnimationProto","Animation","setInterval","checkPrefix","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","triggers","_inputIsFocused","_clampScrollAndGetDurationMultiplier","_allowNativePanning","touchAction","_overflow","auto","_nestedScroll","_ref5","node","_isScrollT","scrollHeight","clientHeight","scrollWidth","overflowY","overflowX","_isScroll","stopPropagation","_inputObserver","inputs","nested","_captureInputs","_inputExp","isInput","observe","normalizeScroll","normalizer","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","_getScrollNormalizer","ss","ref"],"sourceRoot":""}