vendor: 5,386 bytes, lines 1-153
1(function (global, factory) { 2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : 3 typeof define === 'function' && define.amd ? define(['exports'], factory) : 4 (global = global || self, factory(global.window = global.window || {})); 5}(this, (function (exports) { 'use strict'; 6 7 function _defineProperties(target, props) { 8 for (var i = 0; i < props.length; i++) { 9 var descriptor = props[i]; 10 descriptor.enumerable = descriptor.enumerable || false; 11 descriptor.configurable = true; 12 if ("value" in descriptor) descriptor.writable = true; 13 Object.defineProperty(target, descriptor.key, descriptor); 14 } 15 } 16 17 function _createClass(Constructor, protoProps, staticProps) { 18 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 19 if (staticProps) _defineProperties(Constructor, staticProps); 20 return Constructor; 21 } 22 23 /*! 24 * Observer 3.11.3 25 * https://greensock.com 26 * 27 * @license Copyright 2008-2022, GreenSock. All rights reserved. 28 * Subject to the terms at https://greensock.com/standard-license or for 29 * Club GreenSock members, the agreement issued with that membership. 30 * @author: Jack Doyle, [email protected] 31 */ 32 var gsap, 33 _coreInitted, 34 _clamp, 35 _win, 36 _doc, 37 _docEl, 38 _body, 39 _isTouch, 40 _pointerType, 41 ScrollTrigger, 42 _root, 43 _normalizer, 44 _eventTypes, 45 _getGSAP = function _getGSAP() { 46 return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap; 47 }, 48 _startup = 1, 49 _observers = [], 50 _scrollers = [], 51 _proxies = [], 52 _getTime = Date.now, 53 _bridge = function _bridge(name, value) { 54 return value; 55 }, 56 _integrate = function _integrate() { 57 var core = ScrollTrigger.core, 58 data = core.bridge || {}, 59 scrollers = core._scrollers, 60 proxies = core._proxies; 61 scrollers.push.apply(scrollers, _scrollers); 62 proxies.push.apply(proxies, _proxies); 63 _scrollers = scrollers; 64 _proxies = proxies; 65 66 _bridge = function _bridge(name, value) { 67 return data[name](value); 68 }; 69 }, 70 _getProxyProp = function _getProxyProp(element, property) { 71 return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property]; 72 }, 73 _isViewport = function _isViewport(el) { 74 return !!~_root.indexOf(el); 75 }, 76 _addListener = function _addListener(element, type, func, nonPassive, capture) { 77 return element.addEventListener(type, func, { 78 passive: !nonPassive, 79 capture: !!capture 80 }); 81 }, 82 _removeListener = function _removeListener(element, type, func, capture) { 83 return element.removeEventListener(type, func, !!capture); 84 }, 85 _scrollLeft = "scrollLeft", 86 _scrollTop = "scrollTop", 87 _onScroll = function _onScroll() { 88 return _normalizer && _normalizer.isPressed || _scrollers.cache++; 89 }, 90 _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) { 91 var cachingFunc = function cachingFunc(value) { 92 if (value || value === 0) { 93 _startup && (_win.history.scrollRestoration = "manual"); 94 var isNormalizing = _normalizer && _normalizer.isPressed; 95 value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0); 96 f(value); 97 cachingFunc.cacheID = _scrollers.cache; 98 isNormalizing && _bridge("ss", value); 99 } else if (doNotCache || _scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) { 100 cachingFunc.cacheID = _scrollers.cache; 101 cachingFunc.v = f(); 102 } 103 104 return cachingFunc.v + cachingFunc.offset; 105 }; 106 107 cachingFunc.offset = 0; 108 return f && cachingFunc; 109 }, 110 _horizontal = { 111 s: _scrollLeft, 112 p: "left", 113 p2: "Left", 114 os: "right", 115 os2: "Right", 116 d: "width", 117 d2: "Width", 118 a: "x", 119 sc: _scrollCacheFunc(function (value) { 120 return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0; 121 }) 122 }, 123 _vertical = { 124 s: _scrollTop, 125 p: "top", 126 p2: "Top", 127 os: "bottom", 128 os2: "Bottom", 129 d: "height", 130 d2: "Height", 131 a: "y", 132 op: _horizontal, 133 sc: _scrollCacheFunc(function (value) { 134 return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0; 135 }) 136 }, 137 _getTarget = function _getTarget(t) { 138 return gsap.utils.toArray(t)[0] || (typeof t === "string" && gsap.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null); 139 }, 140 _getScrollFunc = function _getScrollFunc(element, _ref) { 141 var s = _ref.s, 142 sc = _ref.sc; 143 _isViewport(element) && (element = _doc.scrollingElement || _docEl); 144 145 var i = _scrollers.indexOf(element), 146 offset = sc === _vertical.sc ? 1 : 2; 147 148 !~i && (i = _scrollers.push(element) - 1); 149 _scrollers[i + offset] || element.addEventListener("scroll", _onScroll); 150 var prev = _scrollers[i + offset], 151 func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) { 152 return arguments.length ? element[s] = value : element[s]; 153 }
vendor: 6,449 bytes, lines 153-334
153))); 154 func.target = element; 155 prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth"); 156 return func; 157 }, 158 _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) { 159 var v1 = value, 160 v2 = value, 161 t1 = _getTime(), 162 t2 = t1, 163 min = minTimeRefresh || 50, 164 dropToZeroTime = Math.max(500, min * 3), 165 update = function update(value, force) { 166 var t = _getTime(); 167 168 if (force || t - t1 > min) { 169 v2 = v1; 170 v1 = value; 171 t2 = t1; 172 t1 = t; 173 } else if (useDelta) { 174 v1 += value; 175 } else { 176 v1 = v2 + (value - v2) / (t - t2) * (t1 - t2); 177 } 178 }, 179 reset = function reset() { 180 v2 = v1 = useDelta ? 0 : v1; 181 t2 = t1 = 0; 182 }, 183 getVelocity = function getVelocity(latestValue) { 184 var tOld = t2, 185 vOld = v2, 186 t = _getTime(); 187 188 (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue); 189 return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000; 190 }; 191 192 return { 193 update: update, 194 reset: reset, 195 getVelocity: getVelocity 196 }; 197 }, 198 _getEvent = function _getEvent(e, preventDefault) { 199 preventDefault && !e._gsapAllow && e.preventDefault(); 200 return e.changedTouches ? e.changedTouches[0] : e; 201 }, 202 _getAbsoluteMax = function _getAbsoluteMax(a) { 203 var max = Math.max.apply(Math, a), 204 min = Math.min.apply(Math, a); 205 return Math.abs(max) >= Math.abs(min) ? max : min; 206 }, 207 _setScrollTrigger = function _setScrollTrigger() { 208 ScrollTrigger = gsap.core.globals().ScrollTrigger; 209 ScrollTrigger && ScrollTrigger.core && _integrate(); 210 }, 211 _initCore = function _initCore(core) { 212 gsap = core || _getGSAP(); 213 214 if (gsap && typeof document !== "undefined" && document.body) { 215 _win = window; 216 _doc = document; 217 _docEl = _doc.documentElement; 218 _body = _doc.body; 219 _root = [_win, _doc, _docEl, _body]; 220 _clamp = gsap.utils.clamp; 221 _pointerType = "onpointerenter" in _body ? "pointer" : "mouse"; 222 _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0; 223 _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(","); 224 setTimeout(function () { 225 return _startup = 0; 226 }, 500); 227 228 _setScrollTrigger(); 229 230 _coreInitted = 1; 231 } 232 233 return _coreInitted; 234 }; 235 236 _horizontal.op = _vertical; 237 _scrollers.cache = 0; 238 var Observer = function () { 239 function Observer(vars) { 240 this.init(vars); 241 } 242 243 var _proto = Observer.prototype; 244 245 _proto.init = function init(vars) { 246 _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)"); 247 ScrollTrigger || _setScrollTrigger(); 248 var tolerance = vars.tolerance, 249 dragMinimum = vars.dragMinimum, 250 type = vars.type, 251 target = vars.target, 252 lineHeight = vars.lineHeight, 253 debounce = vars.debounce, 254 preventDefault = vars.preventDefault, 255 onStop = vars.onStop, 256 onStopDelay = vars.onStopDelay, 257 ignore = vars.ignore, 258 wheelSpeed = vars.wheelSpeed, 259 event = vars.event, 260 onDragStart = vars.onDragStart, 261 onDragEnd = vars.onDragEnd, 262 onDrag = vars.onDrag, 263 onPress = vars.onPress, 264 onRelease = vars.onRelease, 265 onRight = vars.onRight, 266 onLeft = vars.onLeft, 267 onUp = vars.onUp, 268 onDown = vars.onDown, 269 onChangeX = vars.onChangeX, 270 onChangeY = vars.onChangeY, 271 onChange = vars.onChange, 272 onToggleX = vars.onToggleX, 273 onToggleY = vars.onToggleY, 274 onHover = vars.onHover, 275 onHoverEnd = vars.onHoverEnd, 276 onMove = vars.onMove, 277 ignoreCheck = vars.ignoreCheck, 278 isNormalizer = vars.isNormalizer, 279 onGestureStart = vars.onGestureStart, 280 onGestureEnd = vars.onGestureEnd, 281 onWheel = vars.onWheel, 282 onEnable = vars.onEnable, 283 onDisable = vars.onDisable, 284 onClick = vars.onClick, 285 scrollSpeed = vars.scrollSpeed, 286 capture = vars.capture, 287 allowClicks = vars.allowClicks, 288 lockAxis = vars.lockAxis, 289 onLockAxis = vars.onLockAxis; 290 this.target = target = _getTarget(target) || _docEl; 291 this.vars = vars; 292 ignore && (ignore = gsap.utils.toArray(ignore)); 293 tolerance = tolerance || 1e-9; 294 dragMinimum = dragMinimum || 0; 295 wheelSpeed = wheelSpeed || 1; 296 scrollSpeed = scrollSpeed || 1; 297 type = type || "wheel,touch,pointer"; 298 debounce = debounce !== false; 299 lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22); 300 301 var id, 302 onStopDelayedCall, 303 dragged, 304 moved, 305 wheeled, 306 locked, 307 axis, 308 self = this, 309 prevDeltaX = 0, 310 prevDeltaY = 0, 311 scrollFuncX = _getScrollFunc(target, _horizontal), 312 scrollFuncY = _getScrollFunc(target, _vertical), 313 scrollX = scrollFuncX(), 314 scrollY = scrollFuncY(), 315 limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown", 316 isViewport = _isViewport(target), 317 ownerDoc = target.ownerDocument || _doc, 318 deltaX = [0, 0, 0], 319 deltaY = [0, 0, 0], 320 onClickTime = 0, 321 clickCapture = function clickCapture() { 322 return onClickTime = _getTime(); 323 }, 324 _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) { 325 return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch); 326 }, 327 onStopFunc = function onStopFunc() { 328 self._vx.reset(); 329 330 self._vy.reset(); 331 332 onStopDelayedCall.pause(); 333 onStop && onStop(self); 334 },
vendor: 4,626 bytes, lines 335-484
335 update = function update() { 336 var dx = self.deltaX = _getAbsoluteMax(deltaX), 337 dy = self.deltaY = _getAbsoluteMax(deltaY), 338 changedX = Math.abs(dx) >= tolerance, 339 changedY = Math.abs(dy) >= tolerance; 340 341 onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY); 342 343 if (changedX) { 344 onRight && self.deltaX > 0 && onRight(self); 345 onLeft && self.deltaX < 0 && onLeft(self); 346 onChangeX && onChangeX(self); 347 onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self); 348 prevDeltaX = self.deltaX; 349 deltaX[0] = deltaX[1] = deltaX[2] = 0; 350 } 351 352 if (changedY) { 353 onDown && self.deltaY > 0 && onDown(self); 354 onUp && self.deltaY < 0 && onUp(self); 355 onChangeY && onChangeY(self); 356 onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self); 357 prevDeltaY = self.deltaY; 358 deltaY[0] = deltaY[1] = deltaY[2] = 0; 359 } 360 361 if (moved || dragged) { 362 onMove && onMove(self); 363 364 if (dragged) { 365 onDrag(self); 366 dragged = false; 367 } 368 369 moved = false; 370 } 371 372 locked && !(locked = false) && onLockAxis && onLockAxis(self); 373 374 if (wheeled) { 375 onWheel(self); 376 wheeled = false; 377 } 378 379 id = 0; 380 }, 381 onDelta = function onDelta(x, y, index) { 382 deltaX[index] += x; 383 deltaY[index] += y; 384 385 self._vx.update(x); 386 387 self._vy.update(y); 388 389 debounce ? id || (id = requestAnimationFrame(update)) : update(); 390 }, 391 onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) { 392 if (lockAxis && !axis) { 393 self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y"; 394 locked = true; 395 } 396 397 if (axis !== "y") { 398 deltaX[2] += x; 399 400 self._vx.update(x, true); 401 } 402 403 if (axis !== "x") { 404 deltaY[2] += y; 405 406 self._vy.update(y, true); 407 } 408 409 debounce ? id || (id = requestAnimationFrame(update)) : update(); 410 }, 411 _onDrag = function _onDrag(e) { 412 if (_ignoreCheck(e, 1)) { 413 return; 414 } 415 416 e = _getEvent(e, preventDefault); 417 var x = e.clientX, 418 y = e.clientY, 419 dx = x - self.x, 420 dy = y - self.y, 421 isDragging = self.isDragging; 422 self.x = x; 423 self.y = y; 424 425 if (isDragging || Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum) { 426 onDrag && (dragged = true); 427 isDragging || (self.isDragging = true); 428 onTouchOrPointerDelta(dx, dy); 429 isDragging || onDragStart && onDragStart(self); 430 } 431 }, 432 _onPress = self.onPress = function (e) { 433 if (_ignoreCheck(e, 1)) { 434 return; 435 } 436 437 self.axis = axis = null; 438 onStopDelayedCall.pause(); 439 self.isPressed = true; 440 e = _getEvent(e); 441 prevDeltaX = prevDeltaY = 0; 442 self.startX = self.x = e.clientX; 443 self.startY = self.y = e.clientY; 444 445 self._vx.reset(); 446 447 self._vy.reset(); 448 449 _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, preventDefault, true); 450 451 self.deltaX = self.deltaY = 0; 452 onPress && onPress(self); 453 }, 454 _onRelease = function _onRelease(e) { 455 if (_ignoreCheck(e, 1)) { 456 return; 457 } 458 459 _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true); 460 461 var wasDragging = self.isDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3), 462 eventData = _getEvent(e); 463 464 if (!wasDragging) { 465 self._vx.reset(); 466 467 self._vy.reset(); 468 469 if (preventDefault && allowClicks) { 470 gsap.delayedCall(0.08, function () { 471 if (_getTime() - onClickTime > 300 && !e.defaultPrevented) { 472 if (e.target.click) { 473 e.target.click(); 474 } else if (ownerDoc.createEvent) { 475 var syntheticEvent = ownerDoc.createEvent("MouseEvents"); 476 syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null); 477 e.target.dispatchEvent(syntheticEvent); 478 } 479 } 480 }); 481 } 482 } 483 484 self.isDragging = self.isGesturing = self.isPressed = false;
vendor: 5,087 bytes, lines 485-621
485 onStop && !isNormalizer && onStopDelayedCall.restart(true); 486 onDragEnd && wasDragging && onDragEnd(self); 487 onRelease && onRelease(self, wasDragging); 488 }, 489 _onGestureStart = function _onGestureStart(e) { 490 return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging); 491 }, 492 _onGestureEnd = function _onGestureEnd() { 493 return (self.isGesturing = false) || onGestureEnd(self); 494 }, 495 onScroll = function onScroll(e) { 496 if (_ignoreCheck(e)) { 497 return; 498 } 499 500 var x = scrollFuncX(), 501 y = scrollFuncY(); 502 onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1); 503 scrollX = x; 504 scrollY = y; 505 onStop && onStopDelayedCall.restart(true); 506 }, 507 _onWheel = function _onWheel(e) { 508 if (_ignoreCheck(e)) { 509 return; 510 } 511 512 e = _getEvent(e, preventDefault); 513 onWheel && (wheeled = true); 514 var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed; 515 onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0); 516 onStop && !isNormalizer && onStopDelayedCall.restart(true); 517 }, 518 _onMove = function _onMove(e) { 519 if (_ignoreCheck(e)) { 520 return; 521 } 522 523 var x = e.clientX, 524 y = e.clientY, 525 dx = x - self.x, 526 dy = y - self.y; 527 self.x = x; 528 self.y = y; 529 moved = true; 530 (dx || dy) && onTouchOrPointerDelta(dx, dy); 531 }, 532 _onHover = function _onHover(e) { 533 self.event = e; 534 onHover(self); 535 }, 536 _onHoverEnd = function _onHoverEnd(e) { 537 self.event = e; 538 onHoverEnd(self); 539 }, 540 _onClick = function _onClick(e) { 541 return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self); 542 }; 543 544 onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause(); 545 self.deltaX = self.deltaY = 0; 546 self._vx = _getVelocityProp(0, 50, true); 547 self._vy = _getVelocityProp(0, 50, true); 548 self.scrollX = scrollFuncX; 549 self.scrollY = scrollFuncY; 550 self.isDragging = self.isGesturing = self.isPressed = false; 551 552 self.enable = function (e) { 553 if (!self.isEnabled) { 554 _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll); 555 556 type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, preventDefault, capture); 557 type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, preventDefault, capture); 558 559 if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) { 560 _addListener(target, _eventTypes[0], _onPress, preventDefault, capture); 561 562 _addListener(ownerDoc, _eventTypes[2], _onRelease); 563 564 _addListener(ownerDoc, _eventTypes[3], _onRelease); 565 566 allowClicks && _addListener(target, "click", clickCapture, false, true); 567 onClick && _addListener(target, "click", _onClick); 568 onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart); 569 onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd); 570 onHover && _addListener(target, _pointerType + "enter", _onHover); 571 onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd); 572 onMove && _addListener(target, _pointerType + "move", _onMove); 573 } 574 575 self.isEnabled = true; 576 e && e.type && _onPress(e); 577 onEnable && onEnable(self); 578 } 579 580 return self; 581 }; 582 583 self.disable = function () { 584 if (self.isEnabled) { 585 _observers.filter(function (o) { 586 return o !== self && _isViewport(o.target); 587 }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll); 588 589 if (self.isPressed) { 590 self._vx.reset(); 591 592 self._vy.reset(); 593 594 _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true); 595 } 596 597 _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture); 598 599 _removeListener(target, "wheel", _onWheel, capture); 600 601 _removeListener(target, _eventTypes[0], _onPress, capture); 602 603 _removeListener(ownerDoc, _eventTypes[2], _onRelease); 604 605 _removeListener(ownerDoc, _eventTypes[3], _onRelease); 606 607 _removeListener(target, "click", clickCapture, true); 608 609 _removeListener(target, "click", _onClick); 610 611 _removeListener(ownerDoc, "gesturestart", _onGestureStart); 612 613 _removeListener(ownerDoc, "gestureend", _onGestureEnd); 614 615 _removeListener(target, _pointerType + "enter", _onHover); 616 617 _removeListener(target, _pointerType + "leave", _onHoverEnd); 618 619 _removeListener(target, _pointerType + "move", _onMove); 620 621 self.isEnabled = self.isPressed = self.isDragging = false;
vendor: 4,222 bytes, lines 622-773
622 onDisable && onDisable(self); 623 } 624 }; 625 626 self.kill = function () { 627 self.disable(); 628 629 var i = _observers.indexOf(self); 630 631 i >= 0 && _observers.splice(i, 1); 632 _normalizer === self && (_normalizer = 0); 633 }; 634 635 _observers.push(self); 636 637 isNormalizer && _isViewport(target) && (_normalizer = self); 638 self.enable(event); 639 }; 640 641 _createClass(Observer, [{ 642 key: "velocityX", 643 get: function get() { 644 return this._vx.getVelocity(); 645 } 646 }, { 647 key: "velocityY", 648 get: function get() { 649 return this._vy.getVelocity(); 650 } 651 }]); 652 653 return Observer; 654 }(); 655 Observer.version = "3.11.3"; 656 657 Observer.create = function (vars) { 658 return new Observer(vars); 659 }; 660 661 Observer.register = _initCore; 662 663 Observer.getAll = function () { 664 return _observers.slice(); 665 }; 666 667 Observer.getById = function (id) { 668 return _observers.filter(function (o) { 669 return o.vars.id === id; 670 })[0]; 671 }; 672 673 _getGSAP() && gsap.registerPlugin(Observer); 674 675 /*! 676 * ScrollTrigger 3.11.3 677 * https://greensock.com 678 * 679 * @license Copyright 2008-2022, GreenSock. All rights reserved. 680 * Subject to the terms at https://greensock.com/standard-license or for 681 * Club GreenSock members, the agreement issued with that membership. 682 * @author: Jack Doyle, [email protected] 683 */ 684 685 var gsap$1, 686 _coreInitted$1, 687 _win$1, 688 _doc$1, 689 _docEl$1, 690 _body$1, 691 _root$1, 692 _resizeDelay, 693 _toArray, 694 _clamp$1, 695 _time2, 696 _syncInterval, 697 _refreshing, 698 _pointerIsDown, 699 _transformProp, 700 _i, 701 _prevWidth, 702 _prevHeight, 703 _autoRefresh, 704 _sort, 705 _suppressOverwrites, 706 _ignoreResize, 707 _normalizer$1, 708 _ignoreMobileResize, 709 _baseScreenHeight, 710 _baseScreenWidth, 711 _fixIOSBug, 712 _context, 713 _scrollRestoration, 714 _limitCallbacks, 715 _startup$1 = 1, 716 _getTime$1 = Date.now, 717 _time1 = _getTime$1(), 718 _lastScrollTime = 0, 719 _enabled = 0, 720 _pointerDownHandler = function _pointerDownHandler() { 721 return _pointerIsDown = 1; 722 }, 723 _pointerUpHandler = function _pointerUpHandler() { 724 return _pointerIsDown = 0; 725 }, 726 _passThrough = function _passThrough(v) { 727 return v; 728 }, 729 _round = function _round(value) { 730 return Math.round(value * 100000) / 100000 || 0; 731 }, 732 _windowExists = function _windowExists() { 733 return typeof window !== "undefined"; 734 }, 735 _getGSAP$1 = function _getGSAP() { 736 return gsap$1 || _windowExists() && (gsap$1 = window.gsap) && gsap$1.registerPlugin && gsap$1; 737 }, 738 _isViewport$1 = function _isViewport(e) { 739 return !!~_root$1.indexOf(e); 740 }, 741 _getBoundsFunc = function _getBoundsFunc(element) { 742 return _getProxyProp(element, "getBoundingClientRect") || (_isViewport$1(element) ? function () { 743 _winOffsets.width = _win$1.innerWidth; 744 _winOffsets.height = _win$1.innerHeight; 745 return _winOffsets; 746 } : function () { 747 return _getBounds(element); 748 }); 749 }, 750 _getSizeFunc = function _getSizeFunc(scroller, isViewport, _ref) { 751 var d = _ref.d, 752 d2 = _ref.d2, 753 a = _ref.a; 754 return (a = _getProxyProp(scroller, "getBoundingClientRect")) ? function () { 755 return a()[d]; 756 } : function () { 757 return (isViewport ? _win$1["inner" + d2] : scroller["client" + d2]) || 0; 758 }; 759 }, 760 _getOffsetsFunc = function _getOffsetsFunc(element, isViewport) { 761 return !isViewport || ~_proxies.indexOf(element) ? _getBoundsFunc(element) : function () { 762 return _winOffsets; 763 }; 764 }, 765 _maxScroll = function _maxScroll(element, _ref2) { 766 var s = _ref2.s, 767 d2 = _ref2.d2, 768 d = _ref2.d, 769 a = _ref2.a; 770 return (s = "scroll" + d2) && (a = _getProxyProp(element, s)) ? a() - _getBoundsFunc(element)()[d] : _isViewport$1(element) ? (_docEl$1[s] || _body$1[s]) - (_win$1["inner" + d2] || _docEl$1["client" + d2] || _body$1["client" + d2]) : element[s] - element["offset" + d2]; 771 }, 772 _iterateAutoRefresh = function _iterateAutoRefresh(func, events) { 773 for (var i = 0; i < _autoRefresh.length; i += 3) {
vendor: 17,069 bytes, lines 774-1304
774 (!events || ~events.indexOf(_autoRefresh[i + 1])) && func(_autoRefresh[i], _autoRefresh[i + 1], _autoRefresh[i + 2]); 775 } 776 }, 777 _isString = function _isString(value) { 778 return typeof value === "string"; 779 }, 780 _isFunction = function _isFunction(value) { 781 return typeof value === "function"; 782 }, 783 _isNumber = function _isNumber(value) { 784 return typeof value === "number"; 785 }, 786 _isObject = function _isObject(value) { 787 return typeof value === "object"; 788 }, 789 _endAnimation = function _endAnimation(animation, reversed, pause) { 790 return animation && animation.progress(reversed ? 0 : 1) && pause && animation.pause(); 791 }, 792 _callback = function _callback(self, func) { 793 if (self.enabled) { 794 var result = func(self); 795 result && result.totalTime && (self.callbackAnimation = result); 796 } 797 }, 798 _abs = Math.abs, 799 _left = "left", 800 _top = "top", 801 _right = "right", 802 _bottom = "bottom", 803 _width = "width", 804 _height = "height", 805 _Right = "Right", 806 _Left = "Left", 807 _Top = "Top", 808 _Bottom = "Bottom", 809 _padding = "padding", 810 _margin = "margin", 811 _Width = "Width", 812 _Height = "Height", 813 _px = "px", 814 _getComputedStyle = function _getComputedStyle(element) { 815 return _win$1.getComputedStyle(element); 816 }, 817 _makePositionable = function _makePositionable(element) { 818 var position = _getComputedStyle(element).position; 819 820 element.style.position = position === "absolute" || position === "fixed" ? position : "relative"; 821 }, 822 _setDefaults = function _setDefaults(obj, defaults) { 823 for (var p in defaults) { 824 p in obj || (obj[p] = defaults[p]); 825 } 826 827 return obj; 828 }, 829 _getBounds = function _getBounds(element, withoutTransforms) { 830 var tween = withoutTransforms && _getComputedStyle(element)[_transformProp] !== "matrix(1, 0, 0, 1, 0, 0)" && gsap$1.to(element, { 831 x: 0, 832 y: 0, 833 xPercent: 0, 834 yPercent: 0, 835 rotation: 0, 836 rotationX: 0, 837 rotationY: 0, 838 scale: 1, 839 skewX: 0, 840 skewY: 0 841 }).progress(1), 842 bounds = element.getBoundingClientRect(); 843 tween && tween.progress(0).kill(); 844 return bounds; 845 }, 846 _getSize = function _getSize(element, _ref3) { 847 var d2 = _ref3.d2; 848 return element["offset" + d2] || element["client" + d2] || 0; 849 }, 850 _getLabelRatioArray = function _getLabelRatioArray(timeline) { 851 var a = [], 852 labels = timeline.labels, 853 duration = timeline.duration(), 854 p; 855 856 for (p in labels) { 857 a.push(labels[p] / duration); 858 } 859 860 return a; 861 }, 862 _getClosestLabel = function _getClosestLabel(animation) { 863 return function (value) { 864 return gsap$1.utils.snap(_getLabelRatioArray(animation), value); 865 }; 866 }, 867 _snapDirectional = function _snapDirectional(snapIncrementOrArray) { 868 var snap = gsap$1.utils.snap(snapIncrementOrArray), 869 a = Array.isArray(snapIncrementOrArray) && snapIncrementOrArray.slice(0).sort(function (a, b) { 870 return a - b; 871 }); 872 return a ? function (value, direction, threshold) { 873 if (threshold === void 0) { 874 threshold = 1e-3; 875 } 876 877 var i; 878 879 if (!direction) { 880 return snap(value); 881 } 882 883 if (direction > 0) { 884 value -= threshold; 885 886 for (i = 0; i < a.length; i++) { 887 if (a[i] >= value) { 888 return a[i]; 889 } 890 } 891 892 return a[i - 1]; 893 } else { 894 i = a.length; 895 value += threshold; 896 897 while (i--) { 898 if (a[i] <= value) { 899 return a[i]; 900 } 901 } 902 } 903 904 return a[0]; 905 } : function (value, direction, threshold) { 906 if (threshold === void 0) { 907 threshold = 1e-3; 908 } 909 910 var snapped = snap(value); 911 return !direction || Math.abs(snapped - value) < threshold || snapped - value < 0 === direction < 0 ? snapped : snap(direction < 0 ? value - snapIncrementOrArray : value + snapIncrementOrArray); 912 }; 913 }, 914 _getLabelAtDirection = function _getLabelAtDirection(timeline) { 915 return function (value, st) { 916 return _snapDirectional(_getLabelRatioArray(timeline))(value, st.direction); 917 }; 918 }, 919 _multiListener = function _multiListener(func, element, types, callback) { 920 return types.split(",").forEach(function (type) { 921 return func(element, type, callback); 922 }); 923 }, 924 _addListener$1 = function _addListener(element, type, func, nonPassive, capture) { 925 return element.addEventListener(type, func, { 926 passive: !nonPassive, 927 capture: !!capture 928 }); 929 }, 930 _removeListener$1 = function _removeListener(element, type, func, capture) { 931 return element.removeEventListener(type, func, !!capture); 932 }, 933 _wheelListener = function _wheelListener(func, el, scrollFunc) { 934 return scrollFunc && scrollFunc.wheelHandler && func(el, "wheel", scrollFunc); 935 }, 936 _markerDefaults = { 937 startColor: "green", 938 endColor: "red", 939 indent: 0, 940 fontSize: "16px", 941 fontWeight: "normal" 942 }, 943 _defaults = { 944 toggleActions: "play", 945 anticipatePin: 0 946 }, 947 _keywords = { 948 top: 0, 949 left: 0, 950 center: 0.5, 951 bottom: 1, 952 right: 1 953 }, 954 _offsetToPx = function _offsetToPx(value, size) { 955 if (_isString(value)) { 956 var eqIndex = value.indexOf("="), 957 relative = ~eqIndex ? +(value.charAt(eqIndex - 1) + 1) * parseFloat(value.substr(eqIndex + 1)) : 0; 958 959 if (~eqIndex) { 960 value.indexOf("%") > eqIndex && (relative *= size / 100); 961 value = value.substr(0, eqIndex - 1); 962 } 963 964 value = relative + (value in _keywords ? _keywords[value] * size : ~value.indexOf("%") ? parseFloat(value) * size / 100 : parseFloat(value) || 0); 965 } 966 967 return value; 968 }, 969 _createMarker = function _createMarker(type, name, container, direction, _ref4, offset, matchWidthEl, containerAnimation) { 970 var startColor = _ref4.startColor, 971 endColor = _ref4.endColor, 972 fontSize = _ref4.fontSize, 973 indent = _ref4.indent, 974 fontWeight = _ref4.fontWeight; 975 976 var e = _doc$1.createElement("div"), 977 useFixedPosition = _isViewport$1(container) || _getProxyProp(container, "pinType") === "fixed", 978 isScroller = type.indexOf("scroller") !== -1, 979 parent = useFixedPosition ? _body$1 : container, 980 isStart = type.indexOf("start") !== -1, 981 color = isStart ? startColor : endColor, 982 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;"; 983 984 css += "position:" + ((isScroller || containerAnimation) && useFixedPosition ? "fixed;" : "absolute;"); 985 (isScroller || containerAnimation || !useFixedPosition) && (css += (direction === _vertical ? _right : _bottom) + ":" + (offset + parseFloat(indent)) + "px;"); 986 matchWidthEl && (css += "box-sizing:border-box;text-align:left;width:" + matchWidthEl.offsetWidth + "px;"); 987 e._isStart = isStart; 988 e.setAttribute("class", "gsap-marker-" + type + (name ? " marker-" + name : "")); 989 e.style.cssText = css; 990 e.innerText = name || name === 0 ? type + "-" + name : type; 991 parent.children[0] ? parent.insertBefore(e, parent.children[0]) : parent.appendChild(e); 992 e._offset = e["offset" + direction.op.d2]; 993 994 _positionMarker(e, 0, direction, isStart); 995 996 return e; 997 }, 998 _positionMarker = function _positionMarker(marker, start, direction, flipped) { 999 var vars = { 1000 display: "block" 1001 }, 1002 side = direction[flipped ? "os2" : "p2"], 1003 oppositeSide = direction[flipped ? "p2" : "os2"]; 1004 marker._isFlipped = flipped; 1005 vars[direction.a + "Percent"] = flipped ? -100 : 0; 1006 vars[direction.a] = flipped ? "1px" : 0; 1007 vars["border" + side + _Width] = 1; 1008 vars["border" + oppositeSide + _Width] = 0; 1009 vars[direction.p] = start + "px"; 1010 gsap$1.set(marker, vars); 1011 }, 1012 _triggers = [], 1013 _ids = {}, 1014 _rafID, 1015 _sync = function _sync() { 1016 return _getTime$1() - _lastScrollTime > 34 && (_rafID || (_rafID = requestAnimationFrame(_updateAll))); 1017 }, 1018 _onScroll$1 = function _onScroll() { 1019 if (!_normalizer$1 || !_normalizer$1.isPressed || _normalizer$1.startX > _body$1.clientWidth) { 1020 _scrollers.cache++; 1021 1022 if (_normalizer$1) { 1023 _rafID || (_rafID = requestAnimationFrame(_updateAll)); 1024 } else { 1025 _updateAll(); 1026 } 1027 1028 _lastScrollTime || _dispatch("scrollStart"); 1029 _lastScrollTime = _getTime$1(); 1030 } 1031 }, 1032 _setBaseDimensions = function _setBaseDimensions() { 1033 _baseScreenWidth = _win$1.innerWidth; 1034 _baseScreenHeight = _win$1.innerHeight; 1035 }, 1036 _onResize = function _onResize() { 1037 _scrollers.cache++; 1038 !_refreshing && !_ignoreResize && !_doc$1.fullscreenElement && !_doc$1.webkitFullscreenElement && (!_ignoreMobileResize || _baseScreenWidth !== _win$1.innerWidth || Math.abs(_win$1.innerHeight - _baseScreenHeight) > _win$1.innerHeight * 0.25) && _resizeDelay.restart(true); 1039 }, 1040 _listeners = {}, 1041 _emptyArray = [], 1042 _softRefresh = function _softRefresh() { 1043 return _removeListener$1(ScrollTrigger$1, "scrollEnd", _softRefresh) || _refreshAll(true); 1044 }, 1045 _dispatch = function _dispatch(type) { 1046 return _listeners[type] && _listeners[type].map(function (f) { 1047 return f(); 1048 }) || _emptyArray; 1049 }, 1050 _savedStyles = [], 1051 _revertRecorded = function _revertRecorded(media) { 1052 for (var i = 0; i < _savedStyles.length; i += 5) { 1053 if (!media || _savedStyles[i + 4] && _savedStyles[i + 4].query === media) { 1054 _savedStyles[i].style.cssText = _savedStyles[i + 1]; 1055 _savedStyles[i].getBBox && _savedStyles[i].setAttribute("transform", _savedStyles[i + 2] || ""); 1056 _savedStyles[i + 3].uncache = 1; 1057 } 1058 } 1059 }, 1060 _revertAll = function _revertAll(kill, media) { 1061 var trigger; 1062 1063 for (_i = 0; _i < _triggers.length; _i++) { 1064 trigger = _triggers[_i]; 1065 1066 if (trigger && (!media || trigger._ctx === media)) { 1067 if (kill) { 1068 trigger.kill(1); 1069 } else { 1070 trigger.revert(true, true); 1071 } 1072 } 1073 } 1074 1075 media && _revertRecorded(media); 1076 media || _dispatch("revert"); 1077 }, 1078 _clearScrollMemory = function _clearScrollMemory(scrollRestoration, force) { 1079 _scrollers.cache++; 1080 (force || !_refreshingAll) && _scrollers.forEach(function (obj) { 1081 return _isFunction(obj) && obj.cacheID++ && (obj.rec = 0); 1082 }); 1083 _isString(scrollRestoration) && (_win$1.history.scrollRestoration = _scrollRestoration = scrollRestoration); 1084 }, 1085 _refreshingAll, 1086 _refreshID = 0, 1087 _queueRefreshID, 1088 _queueRefreshAll = function _queueRefreshAll() { 1089 if (_queueRefreshID !== _refreshID) { 1090 var id = _queueRefreshID = _refreshID; 1091 requestAnimationFrame(function () { 1092 return id === _refreshID && _refreshAll(true); 1093 }); 1094 } 1095 }, 1096 _refreshAll = function _refreshAll(force, skipRevert) { 1097 if (_lastScrollTime && !force) { 1098 _addListener$1(ScrollTrigger$1, "scrollEnd", _softRefresh); 1099 1100 return; 1101 } 1102 1103 _refreshingAll = ScrollTrigger$1.isRefreshing = true; 1104 1105 _scrollers.forEach(function (obj) { 1106 return _isFunction(obj) && obj.cacheID++ && (obj.rec = obj()); 1107 }); 1108 1109 var refreshInits = _dispatch("refreshInit"); 1110 1111 _sort && ScrollTrigger$1.sort(); 1112 skipRevert || _revertAll(); 1113 1114 _scrollers.forEach(function (obj) { 1115 if (_isFunction(obj)) { 1116 obj.smooth && (obj.target.style.scrollBehavior = "auto"); 1117 obj(0); 1118 } 1119 }); 1120 1121 _triggers.slice(0).forEach(function (t) { 1122 return t.refresh(); 1123 }); 1124 1125 _triggers.forEach(function (t, i) { 1126 if (t._subPinOffset && t.pin) { 1127 var prop = t.vars.horizontal ? "offsetWidth" : "offsetHeight", 1128 original = t.pin[prop]; 1129 t.revert(true, 1); 1130 t.adjustPinSpacing(t.pin[prop] - original); 1131 t.revert(false, 1); 1132 } 1133 }); 1134 1135 _triggers.forEach(function (t) { 1136 return t.vars.end === "max" && t.setPositions(t.start, Math.max(t.start + 1, _maxScroll(t.scroller, t._dir))); 1137 }); 1138 1139 refreshInits.forEach(function (result) { 1140 return result && result.render && result.render(-1); 1141 }); 1142 1143 _scrollers.forEach(function (obj) { 1144 if (_isFunction(obj)) { 1145 obj.smooth && requestAnimationFrame(function () { 1146 return obj.target.style.scrollBehavior = "smooth"; 1147 }); 1148 obj.rec && obj(obj.rec); 1149 } 1150 }); 1151 1152 _clearScrollMemory(_scrollRestoration, 1); 1153 1154 _resizeDelay.pause(); 1155 1156 _refreshID++; 1157 1158 _updateAll(2); 1159 1160 _triggers.forEach(function (t) { 1161 return _isFunction(t.vars.onRefresh) && t.vars.onRefresh(t); 1162 }); 1163 1164 _refreshingAll = ScrollTrigger$1.isRefreshing = false; 1165 1166 _dispatch("refresh"); 1167 }, 1168 _lastScroll = 0, 1169 _direction = 1, 1170 _primary, 1171 _updateAll = function _updateAll(force) { 1172 if (!_refreshingAll || force === 2) { 1173 ScrollTrigger$1.isUpdating = true; 1174 _primary && _primary.update(0); 1175 1176 var l = _triggers.length, 1177 time = _getTime$1(), 1178 recordVelocity = time - _time1 >= 50, 1179 scroll = l && _triggers[0].scroll(); 1180 1181 _direction = _lastScroll > scroll ? -1 : 1; 1182 _lastScroll = scroll; 1183 1184 if (recordVelocity) { 1185 if (_lastScrollTime && !_pointerIsDown && time - _lastScrollTime > 200) { 1186 _lastScrollTime = 0; 1187 1188 _dispatch("scrollEnd"); 1189 } 1190 1191 _time2 = _time1; 1192 _time1 = time; 1193 } 1194 1195 if (_direction < 0) { 1196 _i = l; 1197 1198 while (_i-- > 0) { 1199 _triggers[_i] && _triggers[_i].update(0, recordVelocity); 1200 } 1201 1202 _direction = 1; 1203 } else { 1204 for (_i = 0; _i < l; _i++) { 1205 _triggers[_i] && _triggers[_i].update(0, recordVelocity); 1206 } 1207 } 1208 1209 ScrollTrigger$1.isUpdating = false; 1210 } 1211 1212 _rafID = 0; 1213 }, 1214 _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"], 1215 _stateProps = _propNamesToCopy.concat([_width, _height, "boxSizing", "max" + _Width, "max" + _Height, "position", _margin, _padding, _padding + _Top, _padding + _Right, _padding + _Bottom, _padding + _Left]), 1216 _swapPinOut = function _swapPinOut(pin, spacer, state) { 1217 _setState(state); 1218 1219 var cache = pin._gsap; 1220 1221 if (cache.spacerIsNative) { 1222 _setState(cache.spacerState); 1223 } else if (pin._gsap.swappedIn) { 1224 var parent = spacer.parentNode; 1225 1226 if (parent) { 1227 parent.insertBefore(pin, spacer); 1228 parent.removeChild(spacer); 1229 } 1230 } 1231 1232 pin._gsap.swappedIn = false; 1233 }, 1234 _swapPinIn = function _swapPinIn(pin, spacer, cs, spacerState) { 1235 if (!pin._gsap.swappedIn) { 1236 var i = _propNamesToCopy.length, 1237 spacerStyle = spacer.style, 1238 pinStyle = pin.style, 1239 p; 1240 1241 while (i--) { 1242 p = _propNamesToCopy[i]; 1243 spacerStyle[p] = cs[p]; 1244 } 1245 1246 spacerStyle.position = cs.position === "absolute" ? "absolute" : "relative"; 1247 cs.display === "inline" && (spacerStyle.display = "inline-block"); 1248 pinStyle[_bottom] = pinStyle[_right] = "auto"; 1249 spacerStyle.flexBasis = cs.flexBasis || "auto"; 1250 spacerStyle.overflow = "visible"; 1251 spacerStyle.boxSizing = "border-box"; 1252 spacerStyle[_width] = _getSize(pin, _horizontal) + _px; 1253 spacerStyle[_height] = _getSize(pin, _vertical) + _px; 1254 spacerStyle[_padding] = pinStyle[_margin] = pinStyle[_top] = pinStyle[_left] = "0"; 1255 1256 _setState(spacerState); 1257 1258 pinStyle[_width] = pinStyle["max" + _Width] = cs[_width]; 1259 pinStyle[_height] = pinStyle["max" + _Height] = cs[_height]; 1260 pinStyle[_padding] = cs[_padding]; 1261 1262 if (pin.parentNode !== spacer) { 1263 pin.parentNode.insertBefore(spacer, pin); 1264 spacer.appendChild(pin); 1265 } 1266 1267 pin._gsap.swappedIn = true; 1268 } 1269 }, 1270 _capsExp = /([A-Z])/g, 1271 _setState = function _setState(state) { 1272 if (state) { 1273 var style = state.t.style, 1274 l = state.length, 1275 i = 0, 1276 p, 1277 value; 1278 (state.t._gsap || gsap$1.core.getCache(state.t)).uncache = 1; 1279 1280 for (; i < l; i += 2) { 1281 value = state[i + 1]; 1282 p = state[i]; 1283 1284 if (value) { 1285 style[p] = value; 1286 } else if (style[p]) { 1287 style.removeProperty(p.replace(_capsExp, "-$1").toLowerCase()); 1288 } 1289 } 1290 } 1291 }, 1292 _getState = function _getState(element) { 1293 var l = _stateProps.length, 1294 style = element.style, 1295 state = [], 1296 i = 0; 1297 1298 for (; i < l; i++) { 1299 state.push(_stateProps[i], style[_stateProps[i]]); 1300 } 1301 1302 state.t = element; 1303 return state; 1304 },
vendor: 10,436 bytes, lines 1305-1605
1305 _copyState = function _copyState(state, override, omitOffsets) { 1306 var result = [], 1307 l = state.length, 1308 i = omitOffsets ? 8 : 0, 1309 p; 1310 1311 for (; i < l; i += 2) { 1312 p = state[i]; 1313 result.push(p, p in override ? override[p] : state[i + 1]); 1314 } 1315 1316 result.t = state.t; 1317 return result; 1318 }, 1319 _winOffsets = { 1320 left: 0, 1321 top: 0 1322 }, 1323 _parsePosition = function _parsePosition(value, trigger, scrollerSize, direction, scroll, marker, markerScroller, self, scrollerBounds, borderWidth, useFixedPosition, scrollerMax, containerAnimation) { 1324 _isFunction(value) && (value = value(self)); 1325 1326 if (_isString(value) && value.substr(0, 3) === "max") { 1327 value = scrollerMax + (value.charAt(4) === "=" ? _offsetToPx("0" + value.substr(3), scrollerSize) : 0); 1328 } 1329 1330 var time = containerAnimation ? containerAnimation.time() : 0, 1331 p1, 1332 p2, 1333 element; 1334 containerAnimation && containerAnimation.seek(0); 1335 1336 if (!_isNumber(value)) { 1337 _isFunction(trigger) && (trigger = trigger(self)); 1338 var offsets = (value || "0").split(" "), 1339 bounds, 1340 localOffset, 1341 globalOffset, 1342 display; 1343 element = _getTarget(trigger) || _body$1; 1344 bounds = _getBounds(element) || {}; 1345 1346 if ((!bounds || !bounds.left && !bounds.top) && _getComputedStyle(element).display === "none") { 1347 display = element.style.display; 1348 element.style.display = "block"; 1349 bounds = _getBounds(element); 1350 display ? element.style.display = display : element.style.removeProperty("display"); 1351 } 1352 1353 localOffset = _offsetToPx(offsets[0], bounds[direction.d]); 1354 globalOffset = _offsetToPx(offsets[1] || "0", scrollerSize); 1355 value = bounds[direction.p] - scrollerBounds[direction.p] - borderWidth + localOffset + scroll - globalOffset; 1356 markerScroller && _positionMarker(markerScroller, globalOffset, direction, scrollerSize - globalOffset < 20 || markerScroller._isStart && globalOffset > 20); 1357 scrollerSize -= scrollerSize - globalOffset; 1358 } else if (markerScroller) { 1359 _positionMarker(markerScroller, scrollerSize, direction, true); 1360 } 1361 1362 if (marker) { 1363 var position = value + scrollerSize, 1364 isStart = marker._isStart; 1365 p1 = "scroll" + direction.d2; 1366 1367 _positionMarker(marker, position, direction, isStart && position > 20 || !isStart && (useFixedPosition ? Math.max(_body$1[p1], _docEl$1[p1]) : marker.parentNode[p1]) <= position + 1); 1368 1369 if (useFixedPosition) { 1370 scrollerBounds = _getBounds(markerScroller); 1371 useFixedPosition && (marker.style[direction.op.p] = scrollerBounds[direction.op.p] - direction.op.m - marker._offset + _px); 1372 } 1373 } 1374 1375 if (containerAnimation && element) { 1376 p1 = _getBounds(element); 1377 containerAnimation.seek(scrollerMax); 1378 p2 = _getBounds(element); 1379 containerAnimation._caScrollDist = p1[direction.p] - p2[direction.p]; 1380 value = value / containerAnimation._caScrollDist * scrollerMax; 1381 } 1382 1383 containerAnimation && containerAnimation.seek(time); 1384 return containerAnimation ? value : Math.round(value); 1385 }, 1386 _prefixExp = /(webkit|moz|length|cssText|inset)/i, 1387 _reparent = function _reparent(element, parent, top, left) { 1388 if (element.parentNode !== parent) { 1389 var style = element.style, 1390 p, 1391 cs; 1392 1393 if (parent === _body$1) { 1394 element._stOrig = style.cssText; 1395 cs = _getComputedStyle(element); 1396 1397 for (p in cs) { 1398 if (!+p && !_prefixExp.test(p) && cs[p] && typeof style[p] === "string" && p !== "0") { 1399 style[p] = cs[p]; 1400 } 1401 } 1402 1403 style.top = top; 1404 style.left = left; 1405 } else { 1406 style.cssText = element._stOrig; 1407 } 1408 1409 gsap$1.core.getCache(element).uncache = 1; 1410 parent.appendChild(element); 1411 } 1412 }, 1413 _getTweenCreator = function _getTweenCreator(scroller, direction) { 1414 var getScroll = _getScrollFunc(scroller, direction), 1415 prop = "_scroll" + direction.p2, 1416 lastScroll1, 1417 lastScroll2, 1418 getTween = function getTween(scrollTo, vars, initialValue, change1, change2) { 1419 var tween = getTween.tween, 1420 onComplete = vars.onComplete, 1421 modifiers = {}; 1422 initialValue = initialValue || getScroll(); 1423 change2 = change1 && change2 || 0; 1424 change1 = change1 || scrollTo - initialValue; 1425 tween && tween.kill(); 1426 lastScroll1 = Math.round(initialValue); 1427 vars[prop] = scrollTo; 1428 vars.modifiers = modifiers; 1429 1430 modifiers[prop] = function (value) { 1431 value = Math.round(getScroll()); 1432 1433 if (value !== lastScroll1 && value !== lastScroll2 && Math.abs(value - lastScroll1) > 3 && Math.abs(value - lastScroll2) > 3) { 1434 tween.kill(); 1435 getTween.tween = 0; 1436 } else { 1437 value = initialValue + change1 * tween.ratio + change2 * tween.ratio * tween.ratio; 1438 } 1439 1440 lastScroll2 = lastScroll1; 1441 return lastScroll1 = Math.round(value); 1442 }; 1443 1444 vars.onComplete = function () { 1445 getTween.tween = 0; 1446 onComplete && onComplete.call(tween); 1447 }; 1448 1449 tween = getTween.tween = gsap$1.to(scroller, vars); 1450 return tween; 1451 }; 1452 1453 scroller[prop] = getScroll; 1454 1455 getScroll.wheelHandler = function () { 1456 return getTween.tween && getTween.tween.kill() && (getTween.tween = 0); 1457 }; 1458 1459 _addListener$1(scroller, "wheel", getScroll.wheelHandler); 1460 1461 return getTween; 1462 }; 1463 1464 var ScrollTrigger$1 = function () { 1465 function ScrollTrigger(vars, animation) { 1466 _coreInitted$1 || ScrollTrigger.register(gsap$1) || console.warn("Please gsap.registerPlugin(ScrollTrigger)"); 1467 this.init(vars, animation); 1468 } 1469 1470 var _proto = ScrollTrigger.prototype; 1471 1472 _proto.init = function init(vars, animation) { 1473 this.progress = this.start = 0; 1474 this.vars && this.kill(true, true); 1475 1476 if (!_enabled) { 1477 this.update = this.refresh = this.kill = _passThrough; 1478 return; 1479 } 1480 1481 vars = _setDefaults(_isString(vars) || _isNumber(vars) || vars.nodeType ? { 1482 trigger: vars 1483 } : vars, _defaults); 1484 1485 var _vars = vars, 1486 onUpdate = _vars.onUpdate, 1487 toggleClass = _vars.toggleClass, 1488 id = _vars.id, 1489 onToggle = _vars.onToggle, 1490 onRefresh = _vars.onRefresh, 1491 scrub = _vars.scrub, 1492 trigger = _vars.trigger, 1493 pin = _vars.pin, 1494 pinSpacing = _vars.pinSpacing, 1495 invalidateOnRefresh = _vars.invalidateOnRefresh, 1496 anticipatePin = _vars.anticipatePin, 1497 onScrubComplete = _vars.onScrubComplete, 1498 onSnapComplete = _vars.onSnapComplete, 1499 once = _vars.once, 1500 snap = _vars.snap, 1501 pinReparent = _vars.pinReparent, 1502 pinSpacer = _vars.pinSpacer, 1503 containerAnimation = _vars.containerAnimation, 1504 fastScrollEnd = _vars.fastScrollEnd, 1505 preventOverlaps = _vars.preventOverlaps, 1506 direction = vars.horizontal || vars.containerAnimation && vars.horizontal !== false ? _horizontal : _vertical, 1507 isToggle = !scrub && scrub !== 0, 1508 scroller = _getTarget(vars.scroller || _win$1), 1509 scrollerCache = gsap$1.core.getCache(scroller), 1510 isViewport = _isViewport$1(scroller), 1511 useFixedPosition = ("pinType" in vars ? vars.pinType : _getProxyProp(scroller, "pinType") || isViewport && "fixed") === "fixed", 1512 callbacks = [vars.onEnter, vars.onLeave, vars.onEnterBack, vars.onLeaveBack], 1513 toggleActions = isToggle && vars.toggleActions.split(" "), 1514 markers = "markers" in vars ? vars.markers : _defaults.markers, 1515 borderWidth = isViewport ? 0 : parseFloat(_getComputedStyle(scroller)["border" + direction.p2 + _Width]) || 0, 1516 self = this, 1517 onRefreshInit = vars.onRefreshInit && function () { 1518 return vars.onRefreshInit(self); 1519 }, 1520 getScrollerSize = _getSizeFunc(scroller, isViewport, direction), 1521 getScrollerOffsets = _getOffsetsFunc(scroller, isViewport), 1522 lastSnap = 0, 1523 lastRefresh = 0, 1524 scrollFunc = _getScrollFunc(scroller, direction), 1525 tweenTo, 1526 pinCache, 1527 snapFunc, 1528 scroll1, 1529 scroll2, 1530 start, 1531 end, 1532 markerStart, 1533 markerEnd, 1534 markerStartTrigger, 1535 markerEndTrigger, 1536 markerVars, 1537 change, 1538 pinOriginalState, 1539 pinActiveState, 1540 pinState, 1541 spacer, 1542 offset, 1543 pinGetter, 1544 pinSetter, 1545 pinStart, 1546 pinChange, 1547 spacingStart, 1548 spacerState, 1549 markerStartSetter, 1550 markerEndSetter, 1551 cs, 1552 snap1, 1553 snap2, 1554 scrubTween, 1555 scrubSmooth, 1556 snapDurClamp, 1557 snapDelayedCall, 1558 prevProgress, 1559 prevScroll, 1560 prevAnimProgress, 1561 caMarkerSetter, 1562 customRevertReturn; 1563 1564 _context(self); 1565 1566 self._dir = direction; 1567 anticipatePin *= 45; 1568 self.scroller = scroller; 1569 self.scroll = containerAnimation ? containerAnimation.time.bind(containerAnimation) : scrollFunc; 1570 scroll1 = scrollFunc(); 1571 self.vars = vars; 1572 animation = animation || vars.animation; 1573 1574 if ("refreshPriority" in vars) { 1575 _sort = 1; 1576 vars.refreshPriority === -9999 && (_primary = self); 1577 } 1578 1579 scrollerCache.tweenScroll = scrollerCache.tweenScroll || { 1580 top: _getTweenCreator(scroller, _vertical), 1581 left: _getTweenCreator(scroller, _horizontal) 1582 }; 1583 self.tweenTo = tweenTo = scrollerCache.tweenScroll[direction.p]; 1584 1585 self.scrubDuration = function (value) { 1586 scrubSmooth = _isNumber(value) && value; 1587 1588 if (!scrubSmooth) { 1589 scrubTween && scrubTween.progress(1).kill(); 1590 scrubTween = 0; 1591 } else { 1592 scrubTween ? scrubTween.duration(value) : scrubTween = gsap$1.to(animation, { 1593 ease: "expo", 1594 totalProgress: "+=0.001", 1595 duration: scrubSmooth, 1596 paused: true, 1597 onComplete: function onComplete() { 1598 return onScrubComplete && onScrubComplete(self); 1599 } 1600 }); 1601 } 1602 }; 1603 1604 if (animation) { 1605 animation.vars.lazy = false;
vendor: 4,982 bytes, lines 1606-1708
1606 animation._initted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.duration() && animation.render(0, true, true); 1607 self.animation = animation.pause(); 1608 animation.scrollTrigger = self; 1609 self.scrubDuration(scrub); 1610 snap1 = 0; 1611 id || (id = animation.vars.id); 1612 } 1613 1614 _triggers.push(self); 1615 1616 if (snap) { 1617 if (!_isObject(snap) || snap.push) { 1618 snap = { 1619 snapTo: snap 1620 }; 1621 } 1622 1623 "scrollBehavior" in _body$1.style && gsap$1.set(isViewport ? [_body$1, _docEl$1] : scroller, { 1624 scrollBehavior: "auto" 1625 }); 1626 1627 _scrollers.forEach(function (o) { 1628 return _isFunction(o) && o.target === (isViewport ? _doc$1.scrollingElement || _docEl$1 : scroller) && (o.smooth = false); 1629 }); 1630 1631 snapFunc = _isFunction(snap.snapTo) ? snap.snapTo : snap.snapTo === "labels" ? _getClosestLabel(animation) : snap.snapTo === "labelsDirectional" ? _getLabelAtDirection(animation) : snap.directional !== false ? function (value, st) { 1632 return _snapDirectional(snap.snapTo)(value, _getTime$1() - lastRefresh < 500 ? 0 : st.direction); 1633 } : gsap$1.utils.snap(snap.snapTo); 1634 snapDurClamp = snap.duration || { 1635 min: 0.1, 1636 max: 2 1637 }; 1638 snapDurClamp = _isObject(snapDurClamp) ? _clamp$1(snapDurClamp.min, snapDurClamp.max) : _clamp$1(snapDurClamp, snapDurClamp); 1639 snapDelayedCall = gsap$1.delayedCall(snap.delay || scrubSmooth / 2 || 0.1, function () { 1640 var scroll = scrollFunc(), 1641 refreshedRecently = _getTime$1() - lastRefresh < 500, 1642 tween = tweenTo.tween; 1643 1644 if ((refreshedRecently || Math.abs(self.getVelocity()) < 10) && !tween && !_pointerIsDown && lastSnap !== scroll) { 1645 var progress = (scroll - start) / change, 1646 totalProgress = animation && !isToggle ? animation.totalProgress() : progress, 1647 velocity = refreshedRecently ? 0 : (totalProgress - snap2) / (_getTime$1() - _time2) * 1000 || 0, 1648 change1 = gsap$1.utils.clamp(-progress, 1 - progress, _abs(velocity / 2) * velocity / 0.185), 1649 naturalEnd = progress + (snap.inertia === false ? 0 : change1), 1650 endValue = _clamp$1(0, 1, snapFunc(naturalEnd, self)), 1651 endScroll = Math.round(start + endValue * change), 1652 _snap = snap, 1653 onStart = _snap.onStart, 1654 _onInterrupt = _snap.onInterrupt, 1655 _onComplete = _snap.onComplete; 1656 1657 if (scroll <= end && scroll >= start && endScroll !== scroll) { 1658 if (tween && !tween._initted && tween.data <= _abs(endScroll - scroll)) { 1659 return; 1660 } 1661 1662 if (snap.inertia === false) { 1663 change1 = endValue - progress; 1664 } 1665 1666 tweenTo(endScroll, { 1667 duration: snapDurClamp(_abs(Math.max(_abs(naturalEnd - totalProgress), _abs(endValue - totalProgress)) * 0.185 / velocity / 0.05 || 0)), 1668 ease: snap.ease || "power3", 1669 data: _abs(endScroll - scroll), 1670 onInterrupt: function onInterrupt() { 1671 return snapDelayedCall.restart(true) && _onInterrupt && _onInterrupt(self); 1672 }, 1673 onComplete: function onComplete() { 1674 self.update(); 1675 lastSnap = scrollFunc(); 1676 snap1 = snap2 = animation && !isToggle ? animation.totalProgress() : self.progress; 1677 onSnapComplete && onSnapComplete(self); 1678 _onComplete && _onComplete(self); 1679 } 1680 }, scroll, change1 * change, endScroll - scroll - change1 * change); 1681 onStart && onStart(self, tweenTo.tween); 1682 } 1683 } else if (self.isActive && lastSnap !== scroll) { 1684 snapDelayedCall.restart(true); 1685 } 1686 }).pause(); 1687 } 1688 1689 id && (_ids[id] = self); 1690 trigger = self.trigger = _getTarget(trigger || pin); 1691 customRevertReturn = trigger && trigger._gsap && trigger._gsap.stRevert; 1692 customRevertReturn && (customRevertReturn = customRevertReturn(self)); 1693 pin = pin === true ? trigger : _getTarget(pin); 1694 _isString(toggleClass) && (toggleClass = { 1695 targets: trigger, 1696 className: toggleClass 1697 }); 1698 1699 if (pin) { 1700 pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && pin.parentNode && pin.parentNode.style && _getComputedStyle(pin.parentNode).display === "flex" ? false : _padding); 1701 self.pin = pin; 1702 pinCache = gsap$1.core.getCache(pin); 1703 1704 if (!pinCache.spacer) { 1705 if (pinSpacer) { 1706 pinSpacer = _getTarget(pinSpacer); 1707 pinSpacer && !pinSpacer.nodeType && (pinSpacer = pinSpacer.current || pinSpacer.nativeElement); 1708 pinCache.spacerIsNative = !!pinSpacer;
vendor: 4,542 bytes, lines 1709-1837
1709 pinSpacer && (pinCache.spacerState = _getState(pinSpacer)); 1710 } 1711 1712 pinCache.spacer = spacer = pinSpacer || _doc$1.createElement("div"); 1713 spacer.classList.add("pin-spacer"); 1714 id && spacer.classList.add("pin-spacer-" + id); 1715 pinCache.pinState = pinOriginalState = _getState(pin); 1716 } else { 1717 pinOriginalState = pinCache.pinState; 1718 } 1719 1720 vars.force3D !== false && gsap$1.set(pin, { 1721 force3D: true 1722 }); 1723 self.spacer = spacer = pinCache.spacer; 1724 cs = _getComputedStyle(pin); 1725 spacingStart = cs[pinSpacing + direction.os2]; 1726 pinGetter = gsap$1.getProperty(pin); 1727 pinSetter = gsap$1.quickSetter(pin, direction.a, _px); 1728 1729 _swapPinIn(pin, spacer, cs); 1730 1731 pinState = _getState(pin); 1732 } 1733 1734 if (markers) { 1735 markerVars = _isObject(markers) ? _setDefaults(markers, _markerDefaults) : _markerDefaults; 1736 markerStartTrigger = _createMarker("scroller-start", id, scroller, direction, markerVars, 0); 1737 markerEndTrigger = _createMarker("scroller-end", id, scroller, direction, markerVars, 0, markerStartTrigger); 1738 offset = markerStartTrigger["offset" + direction.op.d2]; 1739 1740 var content = _getTarget(_getProxyProp(scroller, "content") || scroller); 1741 1742 markerStart = this.markerStart = _createMarker("start", id, content, direction, markerVars, offset, 0, containerAnimation); 1743 markerEnd = this.markerEnd = _createMarker("end", id, content, direction, markerVars, offset, 0, containerAnimation); 1744 containerAnimation && (caMarkerSetter = gsap$1.quickSetter([markerStart, markerEnd], direction.a, _px)); 1745 1746 if (!useFixedPosition && !(_proxies.length && _getProxyProp(scroller, "fixedMarkers") === true)) { 1747 _makePositionable(isViewport ? _body$1 : scroller); 1748 1749 gsap$1.set([markerStartTrigger, markerEndTrigger], { 1750 force3D: true 1751 }); 1752 markerStartSetter = gsap$1.quickSetter(markerStartTrigger, direction.a, _px); 1753 markerEndSetter = gsap$1.quickSetter(markerEndTrigger, direction.a, _px); 1754 } 1755 } 1756 1757 if (containerAnimation) { 1758 var oldOnUpdate = containerAnimation.vars.onUpdate, 1759 oldParams = containerAnimation.vars.onUpdateParams; 1760 containerAnimation.eventCallback("onUpdate", function () { 1761 self.update(0, 0, 1); 1762 oldOnUpdate && oldOnUpdate.apply(oldParams || []); 1763 }); 1764 } 1765 1766 self.previous = function () { 1767 return _triggers[_triggers.indexOf(self) - 1]; 1768 }; 1769 1770 self.next = function () { 1771 return _triggers[_triggers.indexOf(self) + 1]; 1772 }; 1773 1774 self.revert = function (revert, temp) { 1775 if (!temp) { 1776 return self.kill(true); 1777 } 1778 1779 var r = revert !== false || !self.enabled, 1780 prevRefreshing = _refreshing; 1781 1782 if (r !== self.isReverted) { 1783 if (r) { 1784 prevScroll = Math.max(scrollFunc(), self.scroll.rec || 0); 1785 prevProgress = self.progress; 1786 prevAnimProgress = animation && animation.progress(); 1787 } 1788 1789 markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) { 1790 return m.style.display = r ? "none" : "block"; 1791 }); 1792 1793 if (r) { 1794 _refreshing = 1; 1795 self.update(r); 1796 } 1797 1798 if (pin) { 1799 if (r) { 1800 _swapPinOut(pin, spacer, pinOriginalState); 1801 } else { 1802 (!pinReparent || !self.isActive) && _swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState); 1803 } 1804 } 1805 1806 r || self.update(r); 1807 _refreshing = prevRefreshing; 1808 self.isReverted = r; 1809 } 1810 }; 1811 1812 self.refresh = function (soft, force) { 1813 if ((_refreshing || !self.enabled) && !force) { 1814 return; 1815 } 1816 1817 if (pin && soft && _lastScrollTime) { 1818 _addListener$1(ScrollTrigger, "scrollEnd", _softRefresh); 1819 1820 return; 1821 } 1822 1823 !_refreshingAll && onRefreshInit && onRefreshInit(self); 1824 _refreshing = 1; 1825 lastRefresh = _getTime$1(); 1826 1827 if (tweenTo.tween) { 1828 tweenTo.tween.kill(); 1829 tweenTo.tween = 0; 1830 } 1831 1832 scrubTween && scrubTween.pause(); 1833 invalidateOnRefresh && animation && animation.revert({ 1834 kill: false 1835 }).invalidate(); 1836 self.isReverted || self.revert(true, true); 1837 self._subPinOffset = false;
1838 1839 var size = getScrollerSize(), 1840 scrollerBounds = getScrollerOffsets(), 1841 max = containerAnimation ? containerAnimation.duration() : _maxScroll(scroller, direction), 1842 offset = 0, 1843 otherPinOffset = 0, 1844 parsedEnd = vars.end, 1845 parsedEndTrigger = vars.endTrigger || trigger, 1846 parsedStart = vars.start || (vars.start === 0 || !trigger ? 0 : pin ? "0 0" : "0 100%"), 1847 pinnedContainer = self.pinnedContainer = vars.pinnedContainer && _getTarget(vars.pinnedContainer), 1848 triggerIndex = trigger && Math.max(0, _triggers.indexOf(self)) || 0, 1849 i = triggerIndex, 1850 cs, 1851 bounds, 1852 scroll, 1853 isVertical, 1854 override, 1855 curTrigger, 1856 curPin, 1857 oppositeScroll, 1858 initted, 1859 revertedPins; 1860 1861 while (i--) { 1862 curTrigger = _triggers[i]; 1863 curTrigger.end || curTrigger.refresh(0, 1) || (_refreshing = 1); 1864 curPin = curTrigger.pin; 1865 1866 if (curPin && (curPin === trigger || curPin === pin) && !curTrigger.isReverted) { 1867 revertedPins || (revertedPins = []); 1868 revertedPins.unshift(curTrigger); 1869 curTrigger.revert(true, true); 1870 } 1871 1872 if (curTrigger !== _triggers[i]) { 1873 triggerIndex--; 1874 i--; 1875 } 1876 } 1877 1878 _isFunction(parsedStart) && (parsedStart = parsedStart(self)); 1879 start = _parsePosition(parsedStart, trigger, size, direction, scrollFunc(), markerStart, markerStartTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation) || (pin ? -0.001 : 0); 1880 _isFunction(parsedEnd) && (parsedEnd = parsedEnd(self)); 1881 1882 if (_isString(parsedEnd) && !parsedEnd.indexOf("+=")) { 1883 if (~parsedEnd.indexOf(" ")) { 1884 parsedEnd = (_isString(parsedStart) ? parsedStart.split(" ")[0] : "") + parsedEnd; 1885 } else { 1886 offset = _offsetToPx(parsedEnd.substr(2), size); 1887 parsedEnd = _isString(parsedStart) ? parsedStart : start + offset; 1888 parsedEndTrigger = trigger; 1889 } 1890 } 1891 1892 end = Math.max(start, _parsePosition(parsedEnd || (parsedEndTrigger ? "100% 0" : max), parsedEndTrigger, size, direction, scrollFunc() + offset, markerEnd, markerEndTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation)) || -0.001; 1893 change = end - start || (start -= 0.01) && 0.001; 1894 offset = 0; 1895 i = triggerIndex; 1896 1897 while (i--) { 1898 curTrigger = _triggers[i]; 1899 curPin = curTrigger.pin; 1900 1901 if (curPin && curTrigger.start - curTrigger._pinPush <= start && !containerAnimation && curTrigger.end > 0) { 1902 cs = curTrigger.end - curTrigger.start; 1903 1904 if ((curPin === trigger && curTrigger.start - curTrigger._pinPush < start || curPin === pinnedContainer) && !_isNumber(parsedStart)) { 1905 offset += cs * (1 - curTrigger.progress); 1906 } 1907 1908 curPin === pin && (otherPinOffset += cs); 1909 } 1910 } 1911 1912 start += offset; 1913 end += offset; 1914 self._pinPush = otherPinOffset; 1915 1916 if (markerStart && offset) { 1917 cs = {}; 1918 cs[direction.a] = "+=" + offset; 1919 pinnedContainer && (cs[direction.p] = "-=" + scrollFunc()); 1920 gsap$1.set([markerStart, markerEnd], cs); 1921 } 1922 1923 if (pin) { 1924 cs = _getComputedStyle(pin); 1925 isVertical = direction === _vertical; 1926 scroll = scrollFunc(); 1927 pinStart = parseFloat(pinGetter(direction.a)) + otherPinOffset; 1928 !max && end > 1 && ((isViewport ? _body$1 : scroller).style["overflow-" + direction.a] = "scroll"); 1929 1930 _swapPinIn(pin, spacer, cs); 1931 1932 pinState = _getState(pin); 1933 bounds = _getBounds(pin, true); 1934 oppositeScroll = useFixedPosition && _getScrollFunc(scroller, isVertical ? _horizontal : _vertical)(); 1935 1936 if (pinSpacing) { 1937 spacerState = [pinSpacing + direction.os2, change + otherPinOffset + _px]; 1938 spacerState.t = spacer; 1939 i = pinSpacing === _padding ? _getSize(pin, direction) + change + otherPinOffset : 0; 1940 i && spacerState.push(direction.d, i + _px); 1941 1942 _setState(spacerState); 1943 1944 if (pinnedContainer) {
vendor: 5,930 bytes, lines 1945-2095
1945 _triggers.forEach(function (t) { 1946 if (t.pin === pinnedContainer && t.vars.pinSpacing !== false) { 1947 t._subPinOffset = true; 1948 } 1949 }); 1950 } 1951 1952 useFixedPosition && scrollFunc(prevScroll); 1953 } 1954 1955 if (useFixedPosition) { 1956 override = { 1957 top: bounds.top + (isVertical ? scroll - start : oppositeScroll) + _px, 1958 left: bounds.left + (isVertical ? oppositeScroll : scroll - start) + _px, 1959 boxSizing: "border-box", 1960 position: "fixed" 1961 }; 1962 override[_width] = override["max" + _Width] = Math.ceil(bounds.width) + _px; 1963 override[_height] = override["max" + _Height] = Math.ceil(bounds.height) + _px; 1964 override[_margin] = override[_margin + _Top] = override[_margin + _Right] = override[_margin + _Bottom] = override[_margin + _Left] = "0"; 1965 override[_padding] = cs[_padding]; 1966 override[_padding + _Top] = cs[_padding + _Top]; 1967 override[_padding + _Right] = cs[_padding + _Right]; 1968 override[_padding + _Bottom] = cs[_padding + _Bottom]; 1969 override[_padding + _Left] = cs[_padding + _Left]; 1970 pinActiveState = _copyState(pinOriginalState, override, pinReparent); 1971 _refreshingAll && scrollFunc(0); 1972 } 1973 1974 if (animation) { 1975 initted = animation._initted; 1976 1977 _suppressOverwrites(1); 1978 1979 animation.render(animation.duration(), true, true); 1980 pinChange = pinGetter(direction.a) - pinStart + change + otherPinOffset; 1981 change !== pinChange && useFixedPosition && pinActiveState.splice(pinActiveState.length - 2, 2); 1982 animation.render(0, true, true); 1983 initted || animation.invalidate(true); 1984 animation.parent || animation.totalTime(animation.totalTime()); 1985 1986 _suppressOverwrites(0); 1987 } else { 1988 pinChange = change; 1989 } 1990 } else if (trigger && scrollFunc() && !containerAnimation) { 1991 bounds = trigger.parentNode; 1992 1993 while (bounds && bounds !== _body$1) { 1994 if (bounds._pinOffset) { 1995 start -= bounds._pinOffset; 1996 end -= bounds._pinOffset; 1997 } 1998 1999 bounds = bounds.parentNode; 2000 } 2001 } 2002 2003 revertedPins && revertedPins.forEach(function (t) { 2004 return t.revert(false, true); 2005 }); 2006 self.start = start; 2007 self.end = end; 2008 scroll1 = scroll2 = _refreshingAll ? prevScroll : scrollFunc(); 2009 2010 if (!containerAnimation && !_refreshingAll) { 2011 scroll1 < prevScroll && scrollFunc(prevScroll); 2012 self.scroll.rec = 0; 2013 } 2014 2015 self.revert(false, true); 2016 2017 if (snapDelayedCall) { 2018 lastSnap = -1; 2019 self.isActive && scrollFunc(start + change * prevProgress); 2020 snapDelayedCall.restart(true); 2021 } 2022 2023 _refreshing = 0; 2024 animation && isToggle && (animation._initted || prevAnimProgress) && animation.progress() !== prevAnimProgress && animation.progress(prevAnimProgress, true).render(animation.time(), true, true); 2025 2026 if (prevProgress !== self.progress || containerAnimation) { 2027 animation && !isToggle && animation.totalProgress(prevProgress, true); 2028 self.progress = (scroll1 - start) / change === prevProgress ? 0 : prevProgress; 2029 } 2030 2031 pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange)); 2032 onRefresh && !_refreshingAll && onRefresh(self); 2033 }; 2034 2035 self.getVelocity = function () { 2036 return (scrollFunc() - scroll2) / (_getTime$1() - _time2) * 1000 || 0; 2037 }; 2038 2039 self.endAnimation = function () { 2040 _endAnimation(self.callbackAnimation); 2041 2042 if (animation) { 2043 scrubTween ? scrubTween.progress(1) : !animation.paused() ? _endAnimation(animation, animation.reversed()) : isToggle || _endAnimation(animation, self.direction < 0, 1); 2044 } 2045 }; 2046 2047 self.labelToScroll = function (label) { 2048 return animation && animation.labels && (start || self.refresh() || start) + animation.labels[label] / animation.duration() * change || 0; 2049 }; 2050 2051 self.getTrailing = function (name) { 2052 var i = _triggers.indexOf(self), 2053 a = self.direction > 0 ? _triggers.slice(0, i).reverse() : _triggers.slice(i + 1); 2054 2055 return (_isString(name) ? a.filter(function (t) { 2056 return t.vars.preventOverlaps === name; 2057 }) : a).filter(function (t) { 2058 return self.direction > 0 ? t.end <= start : t.start >= end; 2059 }); 2060 }; 2061 2062 self.update = function (reset, recordVelocity, forceFake) { 2063 if (containerAnimation && !forceFake && !reset) { 2064 return; 2065 } 2066 2067 var scroll = _refreshingAll ? prevScroll : self.scroll(), 2068 p = reset ? 0 : (scroll - start) / change, 2069 clipped = p < 0 ? 0 : p > 1 ? 1 : p || 0, 2070 prevProgress = self.progress, 2071 isActive, 2072 wasActive, 2073 toggleState, 2074 action, 2075 stateChanged, 2076 toggled, 2077 isAtMax, 2078 isTakingAction; 2079 2080 if (recordVelocity) { 2081 scroll2 = scroll1; 2082 scroll1 = containerAnimation ? scrollFunc() : scroll; 2083 2084 if (snap) { 2085 snap2 = snap1; 2086 snap1 = animation && !isToggle ? animation.totalProgress() : clipped; 2087 } 2088 } 2089 2090 anticipatePin && !clipped && pin && !_refreshing && !_startup$1 && _lastScrollTime && start < scroll + (scroll - scroll2) / (_getTime$1() - _time2) * anticipatePin && (clipped = 0.0001); 2091 2092 if (clipped !== prevProgress && self.enabled) { 2093 isActive = self.isActive = !!clipped && clipped < 1; 2094 wasActive = !!prevProgress && prevProgress < 1; 2095 toggled = isActive !== wasActive;
vendor: 4,186 bytes, lines 2096-2187
2096 stateChanged = toggled || !!clipped !== !!prevProgress; 2097 self.direction = clipped > prevProgress ? 1 : -1; 2098 self.progress = clipped; 2099 2100 if (stateChanged && !_refreshing) { 2101 toggleState = clipped && !prevProgress ? 0 : clipped === 1 ? 1 : prevProgress === 1 ? 2 : 3; 2102 2103 if (isToggle) { 2104 action = !toggled && toggleActions[toggleState + 1] !== "none" && toggleActions[toggleState + 1] || toggleActions[toggleState]; 2105 isTakingAction = animation && (action === "complete" || action === "reset" || action in animation); 2106 } 2107 } 2108 2109 preventOverlaps && (toggled || isTakingAction) && (isTakingAction || scrub || !animation) && (_isFunction(preventOverlaps) ? preventOverlaps(self) : self.getTrailing(preventOverlaps).forEach(function (t) { 2110 return t.endAnimation(); 2111 })); 2112 2113 if (!isToggle) { 2114 if (scrubTween && !_refreshing && !_startup$1) { 2115 (containerAnimation || _primary && _primary !== self) && scrubTween.render(scrubTween._dp._time - scrubTween._start); 2116 2117 if (scrubTween.resetTo) { 2118 scrubTween.resetTo("totalProgress", clipped, animation._tTime / animation._tDur); 2119 } else { 2120 scrubTween.vars.totalProgress = clipped; 2121 scrubTween.invalidate().restart(); 2122 } 2123 } else if (animation) { 2124 animation.totalProgress(clipped, !!_refreshing); 2125 } 2126 } 2127 2128 if (pin) { 2129 reset && pinSpacing && (spacer.style[pinSpacing + direction.os2] = spacingStart); 2130 2131 if (!useFixedPosition) { 2132 pinSetter(_round(pinStart + pinChange * clipped)); 2133 } else if (stateChanged) { 2134 isAtMax = !reset && clipped > prevProgress && end + 1 > scroll && scroll + 1 >= _maxScroll(scroller, direction); 2135 2136 if (pinReparent) { 2137 if (!reset && (isActive || isAtMax)) { 2138 var bounds = _getBounds(pin, true), 2139 _offset = scroll - start; 2140 2141 _reparent(pin, _body$1, bounds.top + (direction === _vertical ? _offset : 0) + _px, bounds.left + (direction === _vertical ? 0 : _offset) + _px); 2142 } else { 2143 _reparent(pin, spacer); 2144 } 2145 } 2146 2147 _setState(isActive || isAtMax ? pinActiveState : pinState); 2148 2149 pinChange !== change && clipped < 1 && isActive || pinSetter(pinStart + (clipped === 1 && !isAtMax ? pinChange : 0)); 2150 } 2151 } 2152 2153 snap && !tweenTo.tween && !_refreshing && !_startup$1 && snapDelayedCall.restart(true); 2154 toggleClass && (toggled || once && clipped && (clipped < 1 || !_limitCallbacks)) && _toArray(toggleClass.targets).forEach(function (el) { 2155 return el.classList[isActive || once ? "add" : "remove"](toggleClass.className); 2156 }); 2157 onUpdate && !isToggle && !reset && onUpdate(self); 2158 2159 if (stateChanged && !_refreshing) { 2160 if (isToggle) { 2161 if (isTakingAction) { 2162 if (action === "complete") { 2163 animation.pause().totalProgress(1); 2164 } else if (action === "reset") { 2165 animation.restart(true).pause(); 2166 } else if (action === "restart") { 2167 animation.restart(true); 2168 } else { 2169 animation[action](); 2170 } 2171 } 2172 2173 onUpdate && onUpdate(self); 2174 } 2175 2176 if (toggled || !_limitCallbacks) { 2177 onToggle && toggled && _callback(self, onToggle); 2178 callbacks[toggleState] && _callback(self, callbacks[toggleState]); 2179 once && (clipped === 1 ? self.kill(false, 1) : callbacks[toggleState] = 0); 2180 2181 if (!toggled) { 2182 toggleState = clipped === 1 ? 1 : 3; 2183 callbacks[toggleState] && _callback(self, callbacks[toggleState]); 2184 } 2185 } 2186 2187 if (fastScrollEnd && !isActive && Math.abs(self.getVelocity()) > (_isNumber(fastScrollEnd) ? fastScrollEnd : 2500)) {
vendor: 9,909 bytes, lines 2188-2493
2188 _endAnimation(self.callbackAnimation); 2189 2190 scrubTween ? scrubTween.progress(1) : _endAnimation(animation, action === "reverse" ? 1 : !clipped, 1); 2191 } 2192 } else if (isToggle && onUpdate && !_refreshing) { 2193 onUpdate(self); 2194 } 2195 } 2196 2197 if (markerEndSetter) { 2198 var n = containerAnimation ? scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0) : scroll; 2199 markerStartSetter(n + (markerStartTrigger._isFlipped ? 1 : 0)); 2200 markerEndSetter(n); 2201 } 2202 2203 caMarkerSetter && caMarkerSetter(-scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0)); 2204 }; 2205 2206 self.enable = function (reset, refresh) { 2207 if (!self.enabled) { 2208 self.enabled = true; 2209 2210 _addListener$1(scroller, "resize", _onResize); 2211 2212 _addListener$1(isViewport ? _doc$1 : scroller, "scroll", _onScroll$1); 2213 2214 onRefreshInit && _addListener$1(ScrollTrigger, "refreshInit", onRefreshInit); 2215 2216 if (reset !== false) { 2217 self.progress = prevProgress = 0; 2218 scroll1 = scroll2 = lastSnap = scrollFunc(); 2219 } 2220 2221 refresh !== false && self.refresh(); 2222 } 2223 }; 2224 2225 self.getTween = function (snap) { 2226 return snap && tweenTo ? tweenTo.tween : scrubTween; 2227 }; 2228 2229 self.setPositions = function (newStart, newEnd) { 2230 if (pin) { 2231 pinStart += newStart - start; 2232 pinChange += newEnd - newStart - change; 2233 pinSpacing === _padding && self.adjustPinSpacing(newEnd - newStart - change); 2234 } 2235 2236 self.start = start = newStart; 2237 self.end = end = newEnd; 2238 change = newEnd - newStart; 2239 self.update(); 2240 }; 2241 2242 self.adjustPinSpacing = function (amount) { 2243 if (spacerState) { 2244 var i = spacerState.indexOf(direction.d) + 1; 2245 spacerState[i] = parseFloat(spacerState[i]) + amount + _px; 2246 spacerState[1] = parseFloat(spacerState[1]) + amount + _px; 2247 2248 _setState(spacerState); 2249 } 2250 }; 2251 2252 self.disable = function (reset, allowAnimation) { 2253 if (self.enabled) { 2254 reset !== false && self.revert(true, true); 2255 self.enabled = self.isActive = false; 2256 allowAnimation || scrubTween && scrubTween.pause(); 2257 prevScroll = 0; 2258 pinCache && (pinCache.uncache = 1); 2259 onRefreshInit && _removeListener$1(ScrollTrigger, "refreshInit", onRefreshInit); 2260 2261 if (snapDelayedCall) { 2262 snapDelayedCall.pause(); 2263 tweenTo.tween && tweenTo.tween.kill() && (tweenTo.tween = 0); 2264 } 2265 2266 if (!isViewport) { 2267 var i = _triggers.length; 2268 2269 while (i--) { 2270 if (_triggers[i].scroller === scroller && _triggers[i] !== self) { 2271 return; 2272 } 2273 } 2274 2275 _removeListener$1(scroller, "resize", _onResize); 2276 2277 _removeListener$1(scroller, "scroll", _onScroll$1); 2278 } 2279 } 2280 }; 2281 2282 self.kill = function (revert, allowAnimation) { 2283 self.disable(revert, allowAnimation); 2284 scrubTween && !allowAnimation && scrubTween.kill(); 2285 id && delete _ids[id]; 2286 2287 var i = _triggers.indexOf(self); 2288 2289 i >= 0 && _triggers.splice(i, 1); 2290 i === _i && _direction > 0 && _i--; 2291 i = 0; 2292 2293 _triggers.forEach(function (t) { 2294 return t.scroller === self.scroller && (i = 1); 2295 }); 2296 2297 i || _refreshingAll || (self.scroll.rec = 0); 2298 2299 if (animation) { 2300 animation.scrollTrigger = null; 2301 revert && animation.revert({ 2302 kill: false 2303 }); 2304 allowAnimation || animation.kill(); 2305 } 2306 2307 markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) { 2308 return m.parentNode && m.parentNode.removeChild(m); 2309 }); 2310 _primary === self && (_primary = 0); 2311 2312 if (pin) { 2313 pinCache && (pinCache.uncache = 1); 2314 i = 0; 2315 2316 _triggers.forEach(function (t) { 2317 return t.pin === pin && i++; 2318 }); 2319 2320 i || (pinCache.spacer = 0); 2321 } 2322 2323 vars.onKill && vars.onKill(self); 2324 }; 2325 2326 self.enable(false, false); 2327 customRevertReturn && customRevertReturn(self); 2328 !animation || !animation.add || change ? self.refresh() : gsap$1.delayedCall(0.01, function () { 2329 return start || end || self.refresh(); 2330 }) && (change = 0.01) && (start = end = 0); 2331 pin && _queueRefreshAll(); 2332 }; 2333 2334 ScrollTrigger.register = function register(core) { 2335 if (!_coreInitted$1) { 2336 gsap$1 = core || _getGSAP$1(); 2337 _windowExists() && window.document && ScrollTrigger.enable(); 2338 _coreInitted$1 = _enabled; 2339 } 2340 2341 return _coreInitted$1; 2342 }; 2343 2344 ScrollTrigger.defaults = function defaults(config) { 2345 if (config) { 2346 for (var p in config) { 2347 _defaults[p] = config[p]; 2348 } 2349 } 2350 2351 return _defaults; 2352 }; 2353 2354 ScrollTrigger.disable = function disable(reset, kill) { 2355 _enabled = 0; 2356 2357 _triggers.forEach(function (trigger) { 2358 return trigger[kill ? "kill" : "disable"](reset); 2359 }); 2360 2361 _removeListener$1(_win$1, "wheel", _onScroll$1); 2362 2363 _removeListener$1(_doc$1, "scroll", _onScroll$1); 2364 2365 clearInterval(_syncInterval); 2366 2367 _removeListener$1(_doc$1, "touchcancel", _passThrough); 2368 2369 _removeListener$1(_body$1, "touchstart", _passThrough); 2370 2371 _multiListener(_removeListener$1, _doc$1, "pointerdown,touchstart,mousedown", _pointerDownHandler); 2372 2373 _multiListener(_removeListener$1, _doc$1, "pointerup,touchend,mouseup", _pointerUpHandler); 2374 2375 _resizeDelay.kill(); 2376 2377 _iterateAutoRefresh(_removeListener$1); 2378 2379 for (var i = 0; i < _scrollers.length; i += 3) { 2380 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 1]); 2381 2382 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 2]); 2383 } 2384 }; 2385 2386 ScrollTrigger.enable = function enable() { 2387 _win$1 = window; 2388 _doc$1 = document; 2389 _docEl$1 = _doc$1.documentElement; 2390 _body$1 = _doc$1.body; 2391 2392 if (gsap$1) { 2393 _toArray = gsap$1.utils.toArray; 2394 _clamp$1 = gsap$1.utils.clamp; 2395 _context = gsap$1.core.context || _passThrough; 2396 _suppressOverwrites = gsap$1.core.suppressOverwrites || _passThrough; 2397 _scrollRestoration = _win$1.history.scrollRestoration || "auto"; 2398 gsap$1.core.globals("ScrollTrigger", ScrollTrigger); 2399 2400 if (_body$1) { 2401 _enabled = 1; 2402 Observer.register(gsap$1); 2403 ScrollTrigger.isTouch = Observer.isTouch; 2404 _fixIOSBug = Observer.isTouch && /(iPad|iPhone|iPod|Mac)/g.test(navigator.userAgent); 2405 2406 _addListener$1(_win$1, "wheel", _onScroll$1); 2407 2408 _root$1 = [_win$1, _doc$1, _docEl$1, _body$1]; 2409 2410 if (gsap$1.matchMedia) { 2411 ScrollTrigger.matchMedia = function (vars) { 2412 var mm = gsap$1.matchMedia(), 2413 p; 2414 2415 for (p in vars) { 2416 mm.add(p, vars[p]); 2417 } 2418 2419 return mm; 2420 }; 2421 2422 gsap$1.addEventListener("matchMediaInit", function () { 2423 return _revertAll(); 2424 }); 2425 gsap$1.addEventListener("matchMediaRevert", function () { 2426 return _revertRecorded(); 2427 }); 2428 gsap$1.addEventListener("matchMedia", function () { 2429 _refreshAll(0, 1); 2430 2431 _dispatch("matchMedia"); 2432 }); 2433 gsap$1.matchMedia("(orientation: portrait)", function () { 2434 _setBaseDimensions(); 2435 2436 return _setBaseDimensions; 2437 }); 2438 } else { 2439 console.warn("Requires GSAP 3.11.0 or later"); 2440 } 2441 2442 _setBaseDimensions(); 2443 2444 _addListener$1(_doc$1, "scroll", _onScroll$1); 2445 2446 var bodyStyle = _body$1.style, 2447 border = bodyStyle.borderTopStyle, 2448 AnimationProto = gsap$1.core.Animation.prototype, 2449 bounds, 2450 i; 2451 AnimationProto.revert || Object.defineProperty(AnimationProto, "revert", { 2452 value: function value() { 2453 return this.time(-0.01, true); 2454 } 2455 }); 2456 bodyStyle.borderTopStyle = "solid"; 2457 bounds = _getBounds(_body$1); 2458 _vertical.m = Math.round(bounds.top + _vertical.sc()) || 0; 2459 _horizontal.m = Math.round(bounds.left + _horizontal.sc()) || 0; 2460 border ? bodyStyle.borderTopStyle = border : bodyStyle.removeProperty("border-top-style"); 2461 _syncInterval = setInterval(_sync, 250); 2462 gsap$1.delayedCall(0.5, function () { 2463 return _startup$1 = 0; 2464 }); 2465 2466 _addListener$1(_doc$1, "touchcancel", _passThrough); 2467 2468 _addListener$1(_body$1, "touchstart", _passThrough); 2469 2470 _multiListener(_addListener$1, _doc$1, "pointerdown,touchstart,mousedown", _pointerDownHandler); 2471 2472 _multiListener(_addListener$1, _doc$1, "pointerup,touchend,mouseup", _pointerUpHandler); 2473 2474 _transformProp = gsap$1.utils.checkPrefix("transform"); 2475 2476 _stateProps.push(_transformProp); 2477 2478 _coreInitted$1 = _getTime$1(); 2479 _resizeDelay = gsap$1.delayedCall(0.2, _refreshAll).pause(); 2480 _autoRefresh = [_doc$1, "visibilitychange", function () { 2481 var w = _win$1.innerWidth, 2482 h = _win$1.innerHeight; 2483 2484 if (_doc$1.hidden) { 2485 _prevWidth = w; 2486 _prevHeight = h; 2487 } else if (_prevWidth !== w || _prevHeight !== h) { 2488 _onResize(); 2489 } 2490 }, _doc$1, "DOMContentLoaded", _refreshAll, _win$1, "load", _refreshAll, _win$1, "resize", _onResize]; 2491 2492 _iterateAutoRefresh(_addListener$1); 2493
vendor: 5,132 bytes, lines 2494-2636
2494 _triggers.forEach(function (trigger) { 2495 return trigger.enable(0, 1); 2496 }); 2497 2498 for (i = 0; i < _scrollers.length; i += 3) { 2499 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 1]); 2500 2501 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 2]); 2502 } 2503 } 2504 } 2505 }; 2506 2507 ScrollTrigger.config = function config(vars) { 2508 "limitCallbacks" in vars && (_limitCallbacks = !!vars.limitCallbacks); 2509 var ms = vars.syncInterval; 2510 ms && clearInterval(_syncInterval) || (_syncInterval = ms) && setInterval(_sync, ms); 2511 "ignoreMobileResize" in vars && (_ignoreMobileResize = ScrollTrigger.isTouch === 1 && vars.ignoreMobileResize); 2512 2513 if ("autoRefreshEvents" in vars) { 2514 _iterateAutoRefresh(_removeListener$1) || _iterateAutoRefresh(_addListener$1, vars.autoRefreshEvents || "none"); 2515 _ignoreResize = (vars.autoRefreshEvents + "").indexOf("resize") === -1; 2516 } 2517 }; 2518 2519 ScrollTrigger.scrollerProxy = function scrollerProxy(target, vars) { 2520 var t = _getTarget(target), 2521 i = _scrollers.indexOf(t), 2522 isViewport = _isViewport$1(t); 2523 2524 if (~i) { 2525 _scrollers.splice(i, isViewport ? 6 : 2); 2526 } 2527 2528 if (vars) { 2529 isViewport ? _proxies.unshift(_win$1, vars, _body$1, vars, _docEl$1, vars) : _proxies.unshift(t, vars); 2530 } 2531 }; 2532 2533 ScrollTrigger.clearMatchMedia = function clearMatchMedia(query) { 2534 _triggers.forEach(function (t) { 2535 return t._ctx && t._ctx.query === query && t._ctx.kill(true, true); 2536 }); 2537 }; 2538 2539 ScrollTrigger.isInViewport = function isInViewport(element, ratio, horizontal) { 2540 var bounds = (_isString(element) ? _getTarget(element) : element).getBoundingClientRect(), 2541 offset = bounds[horizontal ? _width : _height] * ratio || 0; 2542 return horizontal ? bounds.right - offset > 0 && bounds.left + offset < _win$1.innerWidth : bounds.bottom - offset > 0 && bounds.top + offset < _win$1.innerHeight; 2543 }; 2544 2545 ScrollTrigger.positionInViewport = function positionInViewport(element, referencePoint, horizontal) { 2546 _isString(element) && (element = _getTarget(element)); 2547 var bounds = element.getBoundingClientRect(), 2548 size = bounds[horizontal ? _width : _height], 2549 offset = referencePoint == null ? size / 2 : referencePoint in _keywords ? _keywords[referencePoint] * size : ~referencePoint.indexOf("%") ? parseFloat(referencePoint) * size / 100 : parseFloat(referencePoint) || 0; 2550 return horizontal ? (bounds.left + offset) / _win$1.innerWidth : (bounds.top + offset) / _win$1.innerHeight; 2551 }; 2552 2553 ScrollTrigger.killAll = function killAll(allowListeners) { 2554 _triggers.forEach(function (t) { 2555 return t.vars.id !== "ScrollSmoother" && t.kill(); 2556 }); 2557 2558 if (allowListeners !== true) { 2559 var listeners = _listeners.killAll || []; 2560 _listeners = {}; 2561 listeners.forEach(function (f) { 2562 return f(); 2563 }); 2564 } 2565 }; 2566 2567 return ScrollTrigger; 2568 }(); 2569 ScrollTrigger$1.version = "3.11.3"; 2570 2571 ScrollTrigger$1.saveStyles = function (targets) { 2572 return targets ? _toArray(targets).forEach(function (target) { 2573 if (target && target.style) { 2574 var i = _savedStyles.indexOf(target); 2575 2576 i >= 0 && _savedStyles.splice(i, 5); 2577 2578 _savedStyles.push(target, target.style.cssText, target.getBBox && target.getAttribute("transform"), gsap$1.core.getCache(target), _context()); 2579 } 2580 }) : _savedStyles; 2581 }; 2582 2583 ScrollTrigger$1.revert = function (soft, media) { 2584 return _revertAll(!soft, media); 2585 }; 2586 2587 ScrollTrigger$1.create = function (vars, animation) { 2588 return new ScrollTrigger$1(vars, animation); 2589 }; 2590 2591 ScrollTrigger$1.refresh = function (safe) { 2592 return safe ? _onResize() : (_coreInitted$1 || ScrollTrigger$1.register()) && _refreshAll(true); 2593 }; 2594 2595 ScrollTrigger$1.update = _updateAll; 2596 ScrollTrigger$1.clearScrollMemory = _clearScrollMemory; 2597 2598 ScrollTrigger$1.maxScroll = function (element, horizontal) { 2599 return _maxScroll(element, horizontal ? _horizontal : _vertical); 2600 }; 2601 2602 ScrollTrigger$1.getScrollFunc = function (element, horizontal) { 2603 return _getScrollFunc(_getTarget(element), horizontal ? _horizontal : _vertical); 2604 }; 2605 2606 ScrollTrigger$1.getById = function (id) { 2607 return _ids[id]; 2608 }; 2609 2610 ScrollTrigger$1.getAll = function () { 2611 return _triggers.filter(function (t) { 2612 return t.vars.id !== "ScrollSmoother"; 2613 }); 2614 }; 2615 2616 ScrollTrigger$1.isScrolling = function () { 2617 return !!_lastScrollTime; 2618 }; 2619 2620 ScrollTrigger$1.snapDirectional = _snapDirectional; 2621 2622 ScrollTrigger$1.addEventListener = function (type, callback) { 2623 var a = _listeners[type] || (_listeners[type] = []); 2624 ~a.indexOf(callback) || a.push(callback); 2625 }; 2626 2627 ScrollTrigger$1.removeEventListener = function (type, callback) { 2628 var a = _listeners[type], 2629 i = a && a.indexOf(callback); 2630 i >= 0 && a.splice(i, 1); 2631 }; 2632 2633 ScrollTrigger$1.batch = function (targets, vars) { 2634 var result = [], 2635 varsCopy = {}, 2636 interval = vars.interval || 0.016,
vendor: 4,596 bytes, lines 2637-2770
2637 batchMax = vars.batchMax || 1e9, 2638 proxyCallback = function proxyCallback(type, callback) { 2639 var elements = [], 2640 triggers = [], 2641 delay = gsap$1.delayedCall(interval, function () { 2642 callback(elements, triggers); 2643 elements = []; 2644 triggers = []; 2645 }).pause(); 2646 return function (self) { 2647 elements.length || delay.restart(true); 2648 elements.push(self.trigger); 2649 triggers.push(self); 2650 batchMax <= elements.length && delay.progress(1); 2651 }; 2652 }, 2653 p; 2654 2655 for (p in vars) { 2656 varsCopy[p] = p.substr(0, 2) === "on" && _isFunction(vars[p]) && p !== "onRefreshInit" ? proxyCallback(p, vars[p]) : vars[p]; 2657 } 2658 2659 if (_isFunction(batchMax)) { 2660 batchMax = batchMax(); 2661 2662 _addListener$1(ScrollTrigger$1, "refresh", function () { 2663 return batchMax = vars.batchMax(); 2664 }); 2665 } 2666 2667 _toArray(targets).forEach(function (target) { 2668 var config = {}; 2669 2670 for (p in varsCopy) { 2671 config[p] = varsCopy[p]; 2672 } 2673 2674 config.trigger = target; 2675 result.push(ScrollTrigger$1.create(config)); 2676 }); 2677 2678 return result; 2679 }; 2680 2681 var _clampScrollAndGetDurationMultiplier = function _clampScrollAndGetDurationMultiplier(scrollFunc, current, end, max) { 2682 current > max ? scrollFunc(max) : current < 0 && scrollFunc(0); 2683 return end > max ? (max - current) / (end - current) : end < 0 ? current / (current - end) : 1; 2684 }, 2685 _allowNativePanning = function _allowNativePanning(target, direction) { 2686 if (direction === true) { 2687 target.style.removeProperty("touch-action"); 2688 } else { 2689 target.style.touchAction = direction === true ? "auto" : direction ? "pan-" + direction + (Observer.isTouch ? " pinch-zoom" : "") : "none"; 2690 } 2691 2692 target === _docEl$1 && _allowNativePanning(_body$1, direction); 2693 }, 2694 _overflow = { 2695 auto: 1, 2696 scroll: 1 2697 }, 2698 _nestedScroll = function _nestedScroll(_ref5) { 2699 var event = _ref5.event, 2700 target = _ref5.target, 2701 axis = _ref5.axis; 2702 2703 var node = (event.changedTouches ? event.changedTouches[0] : event).target, 2704 cache = node._gsap || gsap$1.core.getCache(node), 2705 time = _getTime$1(), 2706 cs; 2707 2708 if (!cache._isScrollT || time - cache._isScrollT > 2000) { 2709 while (node && node.scrollHeight <= node.clientHeight) { 2710 node = node.parentNode; 2711 } 2712 2713 cache._isScroll = node && !_isViewport$1(node) && node !== target && (_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]); 2714 cache._isScrollT = time; 2715 } 2716 2717 if (cache._isScroll || axis === "x") { 2718 event.stopPropagation(); 2719 event._gsapAllow = true; 2720 } 2721 }, 2722 _inputObserver = function _inputObserver(target, type, inputs, nested) { 2723 return Observer.create({ 2724 target: target, 2725 capture: true, 2726 debounce: false, 2727 lockAxis: true, 2728 type: type, 2729 onWheel: nested = nested && _nestedScroll, 2730 onPress: nested, 2731 onDrag: nested, 2732 onScroll: nested, 2733 onEnable: function onEnable() { 2734 return inputs && _addListener$1(_doc$1, Observer.eventTypes[0], _captureInputs, false, true); 2735 }, 2736 onDisable: function onDisable() { 2737 return _removeListener$1(_doc$1, Observer.eventTypes[0], _captureInputs, true); 2738 } 2739 }); 2740 }, 2741 _inputExp = /(input|label|select|textarea)/i, 2742 _inputIsFocused, 2743 _captureInputs = function _captureInputs(e) { 2744 var isInput = _inputExp.test(e.target.tagName); 2745 2746 if (isInput || _inputIsFocused) { 2747 e._gsapAllow = true; 2748 _inputIsFocused = isInput; 2749 } 2750 }, 2751 _getScrollNormalizer = function _getScrollNormalizer(vars) { 2752 _isObject(vars) || (vars = {}); 2753 vars.preventDefault = vars.isNormalizer = vars.allowClicks = true; 2754 vars.type || (vars.type = "wheel,touch"); 2755 vars.debounce = !!vars.debounce; 2756 vars.id = vars.id || "normalizer"; 2757 2758 var _vars2 = vars, 2759 normalizeScrollX = _vars2.normalizeScrollX, 2760 momentum = _vars2.momentum, 2761 allowNestedScroll = _vars2.allowNestedScroll, 2762 self, 2763 maxY, 2764 target = _getTarget(vars.target) || _docEl$1, 2765 smoother = gsap$1.core.globals().ScrollSmoother, 2766 smootherInstance = smoother && smoother.get(), 2767 content = _fixIOSBug && (vars.content && _getTarget(vars.content) || smootherInstance && vars.content !== false && !smootherInstance.smooth() && smootherInstance.content()), 2768 scrollFuncY = _getScrollFunc(target, _vertical), 2769 scrollFuncX = _getScrollFunc(target, _horizontal), 2770 scale = 1,
vendor: 7,844 bytes, lines 2771-3002
2771 initialScale = (Observer.isTouch && _win$1.visualViewport ? _win$1.visualViewport.scale * _win$1.visualViewport.width : _win$1.outerWidth) / _win$1.innerWidth, 2772 wheelRefresh = 0, 2773 resolveMomentumDuration = _isFunction(momentum) ? function () { 2774 return momentum(self); 2775 } : function () { 2776 return momentum || 2.8; 2777 }, 2778 lastRefreshID, 2779 skipTouchMove, 2780 inputObserver = _inputObserver(target, vars.type, true, allowNestedScroll), 2781 resumeTouchMove = function resumeTouchMove() { 2782 return skipTouchMove = false; 2783 }, 2784 scrollClampX = _passThrough, 2785 scrollClampY = _passThrough, 2786 updateClamps = function updateClamps() { 2787 maxY = _maxScroll(target, _vertical); 2788 scrollClampY = _clamp$1(_fixIOSBug ? 1 : 0, maxY); 2789 normalizeScrollX && (scrollClampX = _clamp$1(0, _maxScroll(target, _horizontal))); 2790 lastRefreshID = _refreshID; 2791 }, 2792 removeContentOffset = function removeContentOffset() { 2793 content._gsap.y = _round(parseFloat(content._gsap.y) + scrollFuncY.offset) + "px"; 2794 content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + parseFloat(content._gsap.y) + ", 0, 1)"; 2795 scrollFuncY.offset = scrollFuncY.cacheID = 0; 2796 }, 2797 ignoreDrag = function ignoreDrag() { 2798 if (skipTouchMove) { 2799 requestAnimationFrame(resumeTouchMove); 2800 2801 var offset = _round(self.deltaY / 2), 2802 scroll = scrollClampY(scrollFuncY.v - offset); 2803 2804 if (content && scroll !== scrollFuncY.v + scrollFuncY.offset) { 2805 scrollFuncY.offset = scroll - scrollFuncY.v; 2806 2807 var y = _round((parseFloat(content && content._gsap.y) || 0) - scrollFuncY.offset); 2808 2809 content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + y + ", 0, 1)"; 2810 content._gsap.y = y + "px"; 2811 scrollFuncY.cacheID = _scrollers.cache; 2812 2813 _updateAll(); 2814 } 2815 2816 return true; 2817 } 2818 2819 scrollFuncY.offset && removeContentOffset(); 2820 skipTouchMove = true; 2821 }, 2822 tween, 2823 startScrollX, 2824 startScrollY, 2825 onStopDelayedCall, 2826 onResize = function onResize() { 2827 updateClamps(); 2828 2829 if (tween.isActive() && tween.vars.scrollY > maxY) { 2830 scrollFuncY() > maxY ? tween.progress(1) && scrollFuncY(maxY) : tween.resetTo("scrollY", maxY); 2831 } 2832 }; 2833 2834 content && gsap$1.set(content, { 2835 y: "+=0" 2836 }); 2837 2838 vars.ignoreCheck = function (e) { 2839 return _fixIOSBug && e.type === "touchmove" && ignoreDrag() || scale > 1.05 && e.type !== "touchstart" || self.isGesturing || e.touches && e.touches.length > 1; 2840 }; 2841 2842 vars.onPress = function () { 2843 var prevScale = scale; 2844 scale = _round((_win$1.visualViewport && _win$1.visualViewport.scale || 1) / initialScale); 2845 tween.pause(); 2846 prevScale !== scale && _allowNativePanning(target, scale > 1.01 ? true : normalizeScrollX ? false : "x"); 2847 startScrollX = scrollFuncX(); 2848 startScrollY = scrollFuncY(); 2849 updateClamps(); 2850 lastRefreshID = _refreshID; 2851 }; 2852 2853 vars.onRelease = vars.onGestureStart = function (self, wasDragging) { 2854 scrollFuncY.offset && removeContentOffset(); 2855 2856 if (!wasDragging) { 2857 onStopDelayedCall.restart(true); 2858 } else { 2859 _scrollers.cache++; 2860 var dur = resolveMomentumDuration(), 2861 currentScroll, 2862 endScroll; 2863 2864 if (normalizeScrollX) { 2865 currentScroll = scrollFuncX(); 2866 endScroll = currentScroll + dur * 0.05 * -self.velocityX / 0.227; 2867 dur *= _clampScrollAndGetDurationMultiplier(scrollFuncX, currentScroll, endScroll, _maxScroll(target, _horizontal)); 2868 tween.vars.scrollX = scrollClampX(endScroll); 2869 } 2870 2871 currentScroll = scrollFuncY(); 2872 endScroll = currentScroll + dur * 0.05 * -self.velocityY / 0.227; 2873 dur *= _clampScrollAndGetDurationMultiplier(scrollFuncY, currentScroll, endScroll, _maxScroll(target, _vertical)); 2874 tween.vars.scrollY = scrollClampY(endScroll); 2875 tween.invalidate().duration(dur).play(0.01); 2876 2877 if (_fixIOSBug && tween.vars.scrollY >= maxY || currentScroll >= maxY - 1) { 2878 gsap$1.to({}, { 2879 onUpdate: onResize, 2880 duration: dur 2881 }); 2882 } 2883 } 2884 }; 2885 2886 vars.onWheel = function () { 2887 tween._ts && tween.pause(); 2888 2889 if (_getTime$1() - wheelRefresh > 1000) { 2890 lastRefreshID = 0; 2891 wheelRefresh = _getTime$1(); 2892 } 2893 }; 2894 2895 vars.onChange = function (self, dx, dy, xArray, yArray) { 2896 _refreshID !== lastRefreshID && updateClamps(); 2897 dx && normalizeScrollX && scrollFuncX(scrollClampX(xArray[2] === dx ? startScrollX + (self.startX - self.x) : scrollFuncX() + dx - xArray[1])); 2898 2899 if (dy) { 2900 scrollFuncY.offset && removeContentOffset(); 2901 var isTouch = yArray[2] === dy, 2902 y = isTouch ? startScrollY + self.startY - self.y : scrollFuncY() + dy - yArray[1], 2903 yClamped = scrollClampY(y); 2904 isTouch && y !== yClamped && (startScrollY += yClamped - y); 2905 scrollFuncY(yClamped); 2906 } 2907 2908 (dy || dx) && _updateAll(); 2909 }; 2910 2911 vars.onEnable = function () { 2912 _allowNativePanning(target, normalizeScrollX ? false : "x"); 2913 2914 ScrollTrigger$1.addEventListener("refresh", onResize); 2915 2916 _addListener$1(_win$1, "resize", onResize); 2917 2918 if (scrollFuncY.smooth) { 2919 scrollFuncY.target.style.scrollBehavior = "auto"; 2920 scrollFuncY.smooth = scrollFuncX.smooth = false; 2921 } 2922 2923 inputObserver.enable(); 2924 }; 2925 2926 vars.onDisable = function () { 2927 _allowNativePanning(target, true); 2928 2929 _removeListener$1(_win$1, "resize", onResize); 2930 2931 ScrollTrigger$1.removeEventListener("refresh", onResize); 2932 inputObserver.kill(); 2933 }; 2934 2935 vars.lockAxis = vars.lockAxis !== false; 2936 self = new Observer(vars); 2937 self.iOS = _fixIOSBug; 2938 _fixIOSBug && !scrollFuncY() && scrollFuncY(1); 2939 _fixIOSBug && gsap$1.ticker.add(_passThrough); 2940 onStopDelayedCall = self._dc; 2941 tween = gsap$1.to(self, { 2942 ease: "power4", 2943 paused: true, 2944 scrollX: normalizeScrollX ? "+=0.1" : "+=0", 2945 scrollY: "+=0.1", 2946 onComplete: onStopDelayedCall.vars.onComplete 2947 }); 2948 return self; 2949 }; 2950 2951 ScrollTrigger$1.sort = function (func) { 2952 return _triggers.sort(func || function (a, b) { 2953 return (a.vars.refreshPriority || 0) * -1e6 + a.start - (b.start + (b.vars.refreshPriority || 0) * -1e6); 2954 }); 2955 }; 2956 2957 ScrollTrigger$1.observe = function (vars) { 2958 return new Observer(vars); 2959 }; 2960 2961 ScrollTrigger$1.normalizeScroll = function (vars) { 2962 if (typeof vars === "undefined") { 2963 return _normalizer$1; 2964 } 2965 2966 if (vars === true && _normalizer$1) { 2967 return _normalizer$1.enable(); 2968 } 2969 2970 if (vars === false) { 2971 return _normalizer$1 && _normalizer$1.kill(); 2972 } 2973 2974 var normalizer = vars instanceof Observer ? vars : _getScrollNormalizer(vars); 2975 _normalizer$1 && _normalizer$1.target === normalizer.target && _normalizer$1.kill(); 2976 _isViewport$1(normalizer.target) && (_normalizer$1 = normalizer); 2977 return normalizer; 2978 }; 2979 2980 ScrollTrigger$1.core = { 2981 _getVelocityProp: _getVelocityProp, 2982 _inputObserver: _inputObserver, 2983 _scrollers: _scrollers, 2984 _proxies: _proxies, 2985 bridge: { 2986 ss: function ss() { 2987 _lastScrollTime || _dispatch("scrollStart"); 2988 _lastScrollTime = _getTime$1(); 2989 }, 2990 ref: function ref() { 2991 return _refreshing; 2992 } 2993 } 2994 }; 2995 _getGSAP$1() && gsap$1.registerPlugin(ScrollTrigger$1); 2996 2997 exports.ScrollTrigger = ScrollTrigger$1; 2998 exports.default = ScrollTrigger$1; 2999 3000 if (typeof(window) === 'undefined' || window !== exports) {Object.defineProperty(exports, '__esModule', { value: true });} else {delete window.default;} 3001 3002})));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.