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