https://kricketrestaurants.com/wp-content/themes/kricket/dist/js/index.js?debug=1791541045

364            var overlay = createErrorOverlay(data.diagnostics.html);
365            // $FlowFixMe
366            document.body.appendChild(overlay);
367        }
368    }
369}
370function removeErrorOverlay() {
371    var overlay = document.getElementById(OVERLAY_ID);
372    if (overlay) {
373        overlay.remove();
374        console.log("[parcel] \u2728 Error resolved");
375    }
376}
377function createErrorOverlay(diagnostics) {
378    var overlay = document.createElement('div');
379    overlay.id = OVERLAY_ID;
380    let errorHTML = '<div style="background: black; opacity: 0.85; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; font-family: Menlo, Consolas, monospace; z-index: 9999;">';
381    for (let diagnostic of diagnostics){
382        let stack = diagnostic.frames.length ? diagnostic.frames.reduce((p, frame)=>{
383            return `${p}
384<a href="${protocol === 'wss' ? 'https' : 'http'}://${hostname}:${port}/__parcel_launch_editor?file=${encodeURIComponent(frame.location)}" style="text-decoration: underline; color: #888" onclick="fetch(this.href); return false">${frame.location}</a>
385${frame.code}`;
386        }, '') : diagnostic.stack;
387        errorHTML += `
388      <div>
389        <div style="font-size: 18px; font-weight: bold; margin-top: 20px;">
390          \u{1F6A8} ${diagnostic.message}
391        </div>
392        <pre>${stack}</pre>
393        <div>
394          ${diagnostic.hints.map((hint)=>"<div>\uD83D\uDCA1 " + hint + '</div>').join('')}
395        </div>
396        ${diagnostic.documentation ? `<div>\u{1F4DD} <a style="color: violet" href="${diagnostic.documentation}" target="_blank">Learn more</a></div>` : ''}
397      </div>
398    `;
399    }
400    errorHTML += '</div>';
401    overlay.innerHTML = errorHTML;
402    return overlay;
403}
404function fullReload() {
405    if (typeof location !== 'undefined' && 'reload' in location) location.reload();
406    else if (typeof extCtx !== 'undefined' && extCtx && extCtx.runtime && extCtx.runtime.reload) extCtx.runtime.reload();
407    else try {
408        let { workerData, parentPort } = module.bundle.root('node:worker_threads') /*: any*/ ;
409        if (workerData !== null && workerData !== void 0 && workerData.__parcel) parentPort.postMessage('restart');
410    } catch (err) {
411        console.error("[parcel] \u26A0\uFE0F An HMR update was not accepted. Please restart the process.");
412    }
413}
414function getParents(bundle, id) /*: Array<[ParcelRequire, string]> */ {
415    var modules = bundle.modules;
416    if (!modules) return [];
417    var parents = [];
418    var k, d, dep;
419    for(k in modules)for(d in modules[k][1]){
420        dep = modules[k][1][d];
421        if (dep === id || Array.isArray(dep) && dep[dep.length - 1] === id) parents.push([
422            bundle,
423            k
424        ]);
425    }
426    if (bundle.parent) parents = parents.concat(getParents(bundle.parent, id));
427    return parents;
428}
429function updateLink(link) {
430    var href = link.getAttribute('href');
431    if (!href) return;
432    var newLink = link.cloneNode();
433    newLink.onload = function() {
434        if (link.parentNode !== null) // $FlowFixMe
435        link.parentNode.removeChild(link);
436    };
437    newLink.setAttribute('href', // $FlowFixMe
438    href.split('?')[0] + '?' + Date.now());
439    // $FlowFixMe
440    link.parentNode.insertBefore(newLink, link.nextSibling);
441}
442var cssTimeout = null;
443function reloadCSS() {
444    if (cssTimeout || typeof document === 'undefined') return;
445    cssTimeout = setTimeout(function() {
446        var links = document.querySelectorAll('link[rel="stylesheet"]');
447        for(var i = 0; i < links.length; i++){
448            // $FlowFixMe[incompatible-type]
449            var href /*: string */  = links[i].getAttribute('href');
450            var hostname = getHostname();
451            var servedFromHMRServer = hostname === 'localhost' ? new RegExp('^(https?:\\/\\/(0.0.0.0|127.0.0.1)|localhost):' + getPort()).test(href) : href.indexOf(hostname + ':' + getPort());
452            var absolute = /^https?:\/\//i.test(href) && href.indexOf(location.origin) !== 0 && !servedFromHMRServer;
453            if (!absolute) updateLink(links[i]);
454        }
455        cssTimeout = null;
456    }, 50);
457}
458function hmrDownload(asset) {
459    if (asset.type === 'js') {
460        if (typeof document !== 'undefined') {
461            let script = document.createElement('script');
462            script.src = asset.url + '?t=' + Date.now();
463            if (asset.outputFormat === 'esmodule') script.type = 'module';
464            return new Promise((resolve, reject)=>{
465                var _document$head;
466                script.onload = ()=>resolve(script);
467                script.onerror = reject;
468                (_document$head = document.head) === null || _document$head === void 0 || _document$head.appendChild(script);
469            });
470        } else if (typeof importScripts === 'function') {
471            // Worker scripts
472            if (asset.outputFormat === 'esmodule') return import(asset.url + '?t=' + Date.now());
473            else return new Promise((resolve, reject)=>{
474                try {
475                    importScripts(asset.url + '?t=' + Date.now());
476                    resolve();
477                } catch (err) {
478                    reject(err);
479                }
480            });
481        }
482    }
483}
484async function hmrApplyUpdates(assets) {
485    global.parcelHotUpdate = Object.create(null);
486    let scriptsToRemove;
487    try {
488        // If sourceURL comments aren't supported in eval, we need to load
489        // the update from the dev server over HTTP so that stack traces
490        // are correct in errors/logs. This is much slower than eval, so
491        // we only do it if needed (currently just Safari).
492        // https://bugs.webkit.org/show_bug.cgi?id=137297
493        // This path is also taken if a CSP disallows eval.
494        if (!supportsSourceURL) {
495            let promises = assets.map((asset)=>{
496                var _hmrDownload;
497                return (_hmrDownload = hmrDownload(asset)) === null || _hmrDownload === void 0 ? void 0 : _hmrDownload.catch((err)=>{
498                    // Web extension fix
499                    if (extCtx && extCtx.runtime && extCtx.runtime.getManifest().manifest_version == 3 && typeof ServiceWorkerGlobalScope != 'undefined' && global instanceof ServiceWorkerGlobalScope) {
500                        extCtx.runtime.reload();
501                        return;
502                    }
503                    throw err;
504                });
505            });
506            scriptsToRemove = await Promise.all(promises);
507        }
508        assets.forEach(function(asset) {
509            hmrApply(module.bundle.root, asset);
510        });
511    } finally{
512        delete global.parcelHotUpdate;
513        if (scriptsToRemove) scriptsToRemove.forEach((script)=>{
514            if (script) {
515                var _document$head2;
516                (_document$head2 = document.head) === null || _document$head2 === void 0 || _document$head2.removeChild(script);
517            }
518        });
519    }
520}
521function hmrApply(bundle /*: ParcelRequire */ , asset /*:  HMRAsset */ ) {
522    var modules = bundle.modules;
523    if (!modules) return;
524    if (asset.type === 'css') reloadCSS();
525    else if (asset.type === 'js') {
526        let deps = asset.depsByBundle[bundle.HMR_BUNDLE_ID];
527        if (deps) {
528            if (modules[asset.id]) {
529                // Remove dependencies that are removed and will become orphaned.
530                // This is necessary so that if the asset is added back again, the cache is gone, and we prevent a full page reload.
531                let oldDeps = modules[asset.id][1];
532                for(let dep in oldDeps)if (!deps[dep] || deps[dep] !== oldDeps[dep]) {
533                    let id = oldDeps[dep];
534                    let parents = getParents(module.bundle.root, id);
535                    if (parents.length === 1) hmrDelete(module.bundle.root, id);
536                }
537            }
538            if (supportsSourceURL) // Global eval. We would use `new Function` here but browser
539            // support for source maps is better with eval.
540            (0, eval)(asset.output);
541            // $FlowFixMe
542            let fn = global.parcelHotUpdate[asset.id];
543            modules[asset.id] = [
544                fn,
545                deps
546            ];
547        }
548        // Always traverse to the parent bundle, even if we already replaced the asset in this bundle.
549        // This is required in case modules are duplicated. We need to ensure all instances have the updated code.
550        if (bundle.parent) hmrApply(bundle.parent, asset);
551    }
552}
553function hmrDelete(bundle, id) {
554    let modules = bundle.modules;
555    if (!modules) return;
556    if (modules[id]) {
557        // Collect dependencies that will become orphaned when this module is deleted.
558        let deps = modules[id][1];
559        let orphans = [];
560        for(let dep in deps){
561            let parents = getParents(module.bundle.root, deps[dep]);
562            if (parents.length === 1) orphans.push(deps[dep]);
563        }
564        // Delete the module. This must be done before deleting dependencies in case of circular dependencies.
565        delete modules[id];
566        delete bundle.cache[id];
567        // Now delete the orphans.
568        orphans.forEach((id)=>{
569            hmrDelete(module.bundle.root, id);
570        });
571    } else if (bundle.parent) hmrDelete(bundle.parent, id);
572}
573function hmrAcceptCheck(bundle /*: ParcelRequire */ , id /*: string */ , depsByBundle /*: ?{ [string]: { [string]: string } }*/ ) {
574    checkedAssets = {};
575    if (hmrAcceptCheckOne(bundle, id, depsByBundle)) return true;
576    // Traverse parents breadth first. All possible ancestries must accept the HMR update, or we'll reload.
577    let parents = getParents(module.bundle.root, id);
578    let accepted = false;

939= !1, this.onVirtualScroll = ({ deltaX: t, deltaY: e, event: i })=>{
940            if (i.ctrlKey) return;
941            const s = i.type.includes("touch"), o = i.type.includes("wheel");
942            if (this.options.syncTouch && s && "touchstart" === i.type && !this.isStopped && !this.isLocked) return void this.reset();
943            const n = 0 === t && 0 === e, r = "vertical" === this.options.gestureOrientation && 0 === e || "horizontal" === this.options.gestureOrientation && 0 === t;
944            if (n || r) return;
945            let l = i.composedPath();
946            if (l = l.slice(0, l.indexOf(this.rootElement)), l.find((t)=>{
947                var e, i, n, r, l;
948                return (null === (e = t.hasAttribute) || void 0 === e ? void 0 : e.call(t, "data-lenis-prevent")) || s && (null === (i = t.hasAttribute) || void 0 === i ? void 0 : i.call(t, "data-lenis-prevent-touch")) || o && (null === (n = t.hasAttribute) || void 0 === n ? void 0 : n.call(t, "data-lenis-prevent-wheel")) || (null === (r = t.classList) || void 0 === r ? void 0 : r.contains("lenis")) && !(null === (l = t.classList) || void 0 === l ? void 0 : l.contains("lenis-stopped"));
949            })) return;
950            if (this.isStopped || this.isLocked) return void i.preventDefault();
951            if (this.isSmooth = this.options.syncTouch && s || this.options.smoothWheel && o, !this.isSmooth) return this.isScrolling = !1, void this.animate.stop();
952            i.preventDefault();
953            let h = e;
954            "both" === this.options.gestureOrientation ? h = Math.abs(e) > Math.abs(t) ? e : t : "horizontal" === this.options.gestureOrientation && (h = t);
955            const a = s && this.options.syncTouch, c = s && "touchend" === i.type && Math.abs(h) > 5;
956            c && (h = this.velocity * this.options.touchInertiaMultiplier), this.scrollTo(this.targetScroll + h, Object.assign({
957                programmatic: !1
958            }, a ? {
959                lerp: c ? this.options.syncTouchLerp : 1
960            } : {
961                lerp: this.options.lerp,
962                duration: this.options.duration,
963                easing: this.options.easing
964            }));
965        }, this.onNativeScroll = ()=>{
966            if (!this.__preventNextScrollEvent && !this.isScrolling) {
967                const t = this.animatedScroll;
968                this.animatedScroll = this.targetScroll = this.actualScroll, this.velocity = 0, this.direction = Math.sign(this.animatedScroll - t), this.emit();
969            }
970        }, window.lenisVersion = "1.0.42", t !== document.documentElement && t !== document.body || (t = window), this.options = {
971            wrapper: t,
972            content: e,
973            wheelEventsTarget: i,
974            eventsTarget: s,
975            smoothWheel: o,
976            syncTouch: n,
977            syncTouchLerp: r,
978            touchInertiaMultiplier: l,
979            duration: h,
980            easing: a,
981            lerp: c,
982            infinite: d,
983            gestureOrientation: u,
984            orientation: p,
985            touchMultiplier: m,
986            wheelMultiplier: v,
987            autoResize: g,
988            __experimental__naiveDimensions: S
989        }, this.animate = new Animate, this.emitter = new Emitter, this.dimensions = new Dimensions({
990            wrapper: t,
991            content: e,
992            autoResize: g
993        }), this.toggleClassName("lenis", !0), this.velocity = 0, this.isLocked = !1, this.isStopped = !1, this.isSmooth = n || o, this.isScrolling = !1, this.targetScroll = this.animatedScroll = this.actualScroll, this.options.wrapper.addEventListener("scroll", this.onNativeScroll, !1), this.virtualScroll = new VirtualScroll(s, {
994            touchMultiplier: m,
995            wheelMultiplier: v
996        }), this.virtualScroll.on("scroll", this.onVirtualScroll);
997    }
998    destroy() {
999        this.emitter.destroy(), this.options.wrapper.removeEventListener("scroll", this.onNativeScroll, !1), this.virtualScroll.destroy(), this.dimensions.destroy(), this.toggleClassName("lenis", !1), this.toggleClassName("lenis-smooth", !1), this.toggleClassName("lenis-scrolling", !1), this.toggleClassName("lenis-stopped", !1), this.toggleClassName("lenis-locked", !1);
1000    }
1001    on(t, e) {
1002        return this.emitter.on(t, e);
1003    }
1004    off(t, e) {
1005        return this.emitter.off(t, e);
1006    }
1007    setScroll(t) {
1008        this.isHorizontal ? this.rootElement.scrollLeft = t : this.rootElement.scrollTop = t;
1009    }
1010    resize() {
1011        this.dimensions.resize();
1012    }
1013    emit() {
1014        this.emitter.emit("scroll", this);
1015    }
1016    reset() {

1429Bounce);
1430parcelHelpers.export(exports, "Sine", ()=>Sine);
1431parcelHelpers.export(exports, "Expo", ()=>Expo);
1432parcelHelpers.export(exports, "Circ", ()=>Circ);
1433parcelHelpers.export(exports, "TweenMax", ()=>Tween) //export some internal methods/orojects for use in CSSPlugin so that we can externalize that file and allow custom builds that exclude it.
1434;
1435parcelHelpers.export(exports, "TweenLite", ()=>Tween);
1436parcelHelpers.export(exports, "TimelineMax", ()=>Timeline);
1437parcelHelpers.export(exports, "TimelineLite", ()=>Timeline);
1438parcelHelpers.export(exports, "default", ()=>gsap);
1439parcelHelpers.export(exports, "wrap", ()=>wrap);
1440parcelHelpers.export(exports, "wrapYoyo", ()=>wrapYoyo);
1441parcelHelpers.export(exports, "distribute", ()=>distribute);
1442parcelHelpers.export(exports, "random", ()=>random);
1443parcelHelpers.export(exports, "snap", ()=>snap);
1444parcelHelpers.export(exports, "normalize", ()=>normalize);
1445parcelHelpers.export(exports, "getUnit", ()=>getUnit);
1446parcelHelpers.export(exports, "clamp", ()=>clamp);
1447parcelHelpers.export(exports, "splitColor", ()=>splitColor);
1448parcelHelpers.export(exports, "toArray", ()=>toArray);
1449parcelHelpers.export(exports, "selector", ()=>selector);
1450parcelHelpers.export(exports, "mapRange", ()=>mapRange);
1451parcelHelpers.export(exports, "pipe", ()=>pipe);
1452parcelHelpers.export(exports, "unitize", ()=>unitize);
1453parcelHelpers.export(exports, "interpolate", ()=>interpolate);
1454parcelHelpers.export(exports, "shuffle", ()=>shuffle);
1455parcelHelpers.export(exports, "_getProperty", ()=>_getProperty);
1456parcelHelpers.export(exports, "_numExp", ()=>_numExp);
1457parcelHelpers.export(exports, "_numWithUnitExp", ()=>_numWithUnitExp);
1458parcelHelpers.export(exports, "_isString", ()=>_isString);
1459parcelHelpers.export(exports, "_isUndefined", ()=>_isUndefined);
1460parcelHelpers.export(exports, "_renderComplexString", ()=>_renderComplexString);
1461parcelHelpers.export(exports, "_relExp", ()=>_relExp);
1462parcelHelpers.export(exports, "_setDefaults", ()=>_setDefaults);
1463parcelHelpers.export(exports, "_removeLinkedListItem", ()=>_removeLinkedListItem);
1464parcelHelpers.export(exports, "_forEachName", ()=>_forEachName);
1465parcelHelpers.export(exports, "_sortPropTweensByPriority", ()=>_sortPropTweensByPriority);
1466parcelHelpers.export(exports, "_colorStringFilter", ()=>_colorStringFilter);
1467parcelHelpers.export(exports, "_replaceRandom", ()=>_replaceRandom);
1468parcelHelpers.export(exports, "_checkPlugin", ()=>_checkPlugin);
1469parcelHelpers.export(exports, "_plugins", ()=>_plugins);
1470parcelHelpers.export(exports, "_ticker", ()=>_ticker);
1471parcelHelpers.export(exports, "_config", ()=>_config);
1472parcelHelpers.export(exports, "_roundModifier", ()=>_roundModifier);
1473parcelHelpers.export(exports, "_round", ()=>_round);
1474parcelHelpers.export(exports, "_missingPlugin", ()=>_missingPlugin);
1475parcelHelpers.export(exports, "_getSetter", ()=>_getSetter);
1476parcelHelpers.export(exports, "_getCache", ()=>_getCache);
1477parcelHelpers.export(exports, "_colorExp", ()=>_colorExp);
1478parcelHelpers.export(exports, "_parseRelative", ()=>_parseRelative);
1479function _assertThisInitialized(self) {
1480    if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
1481    return self;
1482}
1483function _inheritsLoose(subClass, superClass) {
1484    subClass.prototype = Object.create(superClass.prototype);
1485    subClass.prototype.constructor = subClass;
1486    subClass.__proto__ = superClass;
1487}
1488/*!
1489 * GSAP 3.13.0
1490 * https://gsap.com
1491 *
1492 * @license Copyright 2008-2025, GreenSock. All rights reserved.
1493 * Subject to the terms at https://gsap.com/standard-license
1494 * @author: Jack Doyle, [email protected]
1495*/ /* eslint-disable */ var _config = {
1496    autoSleep: 120,
1497    force3D: "auto",
1498    nullTargetWarn: 1,
1499    units: {
1500        lineHeight: ""
1501    }
1502}, _defaults = {
1503    duration: .5,
1504    overwrite: false,
1505    delay: 0
1506}, _suppressOverwrites, _reverting, _context, _bigNum = 1e8, _tinyNum = 1 / _bigNum, _2PI = Math.PI * 2, _HALF_PI = _2PI / 4, _gsID = 0, _sqrt = Math.sqrt, _cos = Math.cos, _sin = Math.sin, _isString = function _isString(value) {
1507    return typeof value === "string";
1508}, _isFunction = function _isFunction(value) {
1509    return typeof value === "function";
1510}, _isNumber = function _isNumber(value) {
1511    return typeof value === "number";
1512}, _isUndefined = function _isUndefined(value) {
1513    return typeof value === "undefined";
1514}, _isObject = function _isObject(value) {
1515    return typeof value === "object";
1516}, _isNotFalse = function _isNotFalse(value) {
1517    return value !== false;
1518}, _windowExists = function _windowExists() {
1519    return typeof window !== "undefined";
1520}, _isFuncOrString = function _isFuncOrString(value) {
1521    return _isFunction(value) || _isString(value);
1522}, _isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView || function() {}, // note: IE10 has ArrayBuffer, but NOT ArrayBuffer.isView().
1523_isArray = Array.isArray, _strictNumExp = /(?:-?\.?\d|\.)+/gi, //only numbers (including negatives and decimals) but NOT relative values.
1524_numExp = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/g, //finds any numbers, including ones that start with += or -=, negative numbers, and ones in scientific notation like 1e-8.
1525_numWithUnitExp = /[-+=.]*\d+[.e-]*\d*[a-z%]*/g, _complexStringNumExp = /[-+=.]*\d+\.?\d*(?:e-|e\+)?\d*/gi, //duplicate so that while we're looping through matches from exec(), it doesn't contaminate the lastIndex of _numExp which we use to search for colors too.
1526_relExp = /[+-]=-?[.\d]+/, _delimitedValueExp = /[^,'"\[\]\s]+/gi, // previously /[#\-+.]*\b[a-z\d\-=+%.]+/gi but didn't catch special characters.
1527_unitExp = /^[+\-=e\s\d]*\d+[.\d]*([a-z]*|%)\s*$/i, _globalTimeline, _win, _coreInitted, _doc, _globals = {}, _installScope = {}, _coreReady, _install = function _install(scope) {

1528    return (_installScope = _merge(scope, _globals)) && gsap;
1529}, _missingPlugin = function _missingPlugin(property, value) {
1530    return console.warn("Invalid property", property, "set to", value, "Missing plugin? gsap.registerPlugin()");
1531}, _warn = function _warn(message, suppress) {
1532    return !suppress && console.warn(message);
1533}, _addGlobal = function _addGlobal(name, obj) {
1534    return name && (_globals[name] = obj) && _installScope && (_installScope[name] = obj) || _globals;
1535}, _emptyFunc = function _emptyFunc() {
1536    return 0;
1537}, _startAtRevertConfig = {
1538    suppressEvents: true,
1539    isStart: true,
1540    kill: false
1541}, _revertConfigNoKill = {
1542    suppressEvents: true,
1543    kill: false
1544}, _revertConfig = {
1545    suppressEvents: true
1546}, _reservedProps = {}, _lazyTweens = [], _lazyLookup = {}, _lastRenderedFrame, _plugins = {}, _effects = {}, _nextGCFrame = 30, _harnessPlugins = [], _callbackNames = "", _harness = function _harness(targets) {
1547    var target = targets[0], harnessPlugin, i;
1548    _isObject(target) || _isFunction(target) || (targets = [
1549        targets
1550    ]);
1551    if (!(harnessPlugin = (target._gsap || {}).harness)) {
1552        // find the first target with a harness. We assume targets passed into an animation will be of similar type, meaning the same kind of harness can be used for them all (performance optimization)
1553        i = _harnessPlugins.length;
1554        while(i-- && !_harnessPlugins[i].targetTest(target));
1555        harnessPlugin = _harnessPlugins[i];
1556    }
1557    i = targets.length;
1558    while(i--)targets[i] && (targets[i]._gsap || (targets[i]._gsap = new GSCache(targets[i], harnessPlugin))) || targets.splice(i, 1);
1559    return targets;
1560}, _getCache = function _getCache(target) {
1561    return target._gsap || _harness(toArray(target))[0]._gsap;
1562}, _getProperty = function _getProperty(target, property, v) {
1563    return (v = target[property]) && _isFunction(v) ? target[property]() : _isUndefined(v) && target.getAttribute && target.getAttribute(property) || v;
1564}, _forEachName = function _forEachName(names, func) {
1565    return (names = names.split(",")).forEach(func) || names;
1566}, //split a comma-delimited list of names into an array, then run a forEach() function and return the split array (this is just a way to consolidate/shorten some code).
1567_round = function _round(value) {
1568    return Math.round(value * 100000) / 100000 || 0;
1569}, _roundPrecise = function _roundPrecise(value) {
1570    return Math.round(value * 10000000) / 10000000 || 0;
1571}, // increased precision mostly for timing values.
1572_parseRelative = function _parseRelative(start, value) {
1573    var operator = value.charAt(0), end = parseFloat(value.substr(2));
1574    start = parseFloat(start);
1575    return operator === "+" ? start + end : operator === "-" ? start - end : operator === "*" ? start * end : start / end;
1576}, _arrayContainsAny = function _arrayContainsAny(toSearch, toFind) {
1577    //searches one array to find matches for any of the items in the toFind array. As soon as one is found, it returns true. It does NOT return all the matches; it's simply a boolean search.
1578    var l = toFind.length, i = 0;
1579    for(; toSearch.indexOf(toFind[i]) < 0 && ++i < l;);
1580    return i < l;
1581}, _lazyRender = function _lazyRender() {
1582    var l = _lazyTweens.length, a = _lazyTweens.slice(0), i, tween;
1583    _lazyLookup = {};
1584    _lazyTweens.length = 0;
1585    for(i = 0; i < l; i++){
1586        tween = a[i];
1587        tween && tween._lazy && (tween.render(tween._lazy[0], tween._lazy[1], true)._lazy = 0);
1588    }
1589}, _isRevertWorthy = function _isRevertWorthy(animation) {
1590    return !!(animation._initted || animation._startAt || animation.add);
1591}, _lazySafeRender = function _lazySafeRender(animation, time, suppressEvents, force) {
1592    _lazyTweens.length && !_reverting && _lazyRender();
1593    animation.render(time, suppressEvents, force || !!(_reverting && time < 0 && _isRevertWorthy(animation)));
1594    _lazyTweens.length && !_reverting && _lazyRender(); //in case rendering caused any tweens to lazy-init, we should render them because typically when someone calls seek() or time() or progress(), they expect an immediate render.
1595}, _numericIfPossible = function _numericIfPossible(value) {
1596    var n = parseFloat(value);
1597    return (n || n === 0) && (value + "").match(_delimitedValueExp).length < 2 ? n : _isString(value) ? value.trim() : value;
1598}, _passThrough = function _passThrough(p) {
1599    return p;
1600}, _setDefaults = function _setDefaults(obj, defaults) {
1601    for(var p in defaults)p in obj || (obj[p] = defaults[p]);
1602    return obj;
1603}, _setKeyframeDefaults = function _setKeyframeDefaults(excludeDuration) {
1604    return function(obj, defaults) {
1605        for(var p in defaults)p in obj || p === "duration" && excludeDuration || p === "ease" || (obj[p] = defaults[p]);
1606    };
1607}, _merge = function _merge(base, toMerge) {
1608    for(var p in toMerge)base[p] = toMerge[p];
1609    return base;
1610}, _mergeDeep = function _mergeDeep(base, toMerge) {
1611    for(var p in toMerge)p !== "__proto__" && p !== "constructor" && p !== "prototype" && (base[p] = _isObject(toMerge[p]) ? _mergeDeep(base[p] || (base[p] = {}), toMerge[p]) : toMerge[p]);
1612    return base;
1613}, _copyExcluding = function _copyExcluding(obj, excluding) {
1614    var copy = {}, p;
1615    for(p in obj)p in excluding || (copy[p] = obj[p]);
1616    return copy;
1617}, _inheritDefaults = function _inheritDefaults(vars) {
1618    var parent = vars.parent || _globalTimeline, func = vars.keyframes ? _setKeyframeDefaults(_isArray(vars.keyframes)) : _setDefaults;
1619    if (_isNotFalse(vars.inherit)) while(parent){
1620        func(vars, parent.vars.defaults);
1621        parent = parent.parent || parent._dp;
1622    }
1623    return vars;
1624}, _arraysMatch = function _arraysMatch(a1, a2) {
1625    var i = a1.length, match = i === a2.length;
1626    while(match && i-- && a1[i] === a2[i]);
1627    return i < 0;
1628}, _addLinkedListItem = function _addLinkedListItem(parent, child, firstProp, lastProp, sortBy) {
1629    if (firstProp === void 0) firstProp = "_first";
1630    if (lastProp === void 0) lastProp = "_last";
1631    var prev = parent[lastProp], t;
1632    if (sortBy) {
1633        t = child[sortBy];
1634        while(prev && prev[sortBy] > t)prev = prev._prev;
1635    }
1636    if (prev) {
1637        child._next = prev._next;
1638        prev._next = child;
1639    } else {
1640        child._next = parent[firstProp];
1641        parent[firstProp] = child;
1642    }
1643    if (child._next) child._next._prev = child;
1644    else parent[lastProp] = child;
1645    child._prev = prev;
1646    child.parent = child._dp = parent;
1647    return child;
1648}, _removeLinkedListItem = function _removeLinkedListItem(parent, child, firstProp, lastProp) {
1649    if (firstProp === void 0) firstProp = "_first";
1650    if (lastProp === void 0) lastProp = "_last";
1651    var prev = child._prev, next = child._next;
1652    if (prev) prev._next = next;
1653    else if (parent[firstProp] === child) parent[firstProp] = next;
1654    if (next) next._prev = prev;
1655    else if (parent[lastProp] === child) parent[lastProp] = prev;
1656    child._next = child._prev = child.parent = null; // don't delete the _dp just so we can revert if necessary. But parent should be null to indicate the item isn't in a linked list.
1657}, _removeFromParent = function _removeFromParent(child, onlyIfParentHasAutoRemove) {
1658    child.parent && (!onlyIfParentHasAutoRemove || child.parent.autoRemoveChildren) && child.parent.remove && child.parent.remove(child);
1659    child._act = 0;
1660}, _uncache = function _uncache(animation, child) {
1661    if (animation && (!child || child._end > animation._dur || child._start < 0)) {
1662        // performance optimization: if a child animation is passed in we should only uncache if that child EXTENDS the animation (its end time is beyond the end)
1663        var a = animation;
1664        while(a){
1665            a._dirty = 1;
1666            a = a.parent;
1667        }
1668    }
1669    return animation;
1670}, _recacheAncestors = function _recacheAncestors(animation) {
1671    var parent = animation.parent;
1672    while(parent && parent.parent){
1673        //sometimes we must force a re-sort of all children and update the duration/totalDuration of all ancestor timelines immediately in case, for example, in the middle of a render loop, one tween alters another tween's timeScale which shoves its startTime before 0, forcing the parent timeline to shift around and shiftChildren() which could affect that next tween's render (startTime). Doesn't matter for the root timeline though.
1674        parent._dirty = 1;
1675        parent.totalDuration();
1676        parent = parent.parent;
1677    }
1678    return animation;
1679}, _rewindStartAt = function _rewindStartAt(tween, totalTime, suppressEvents, force) {
1680    return tween._startAt && (_reverting ? tween._startAt.revert(_revertConfigNoKill) : tween.vars.immediateRender && !tween.vars.autoRevert || tween._startAt.render(totalTime, true, force));
1681}, _hasNoPausedAncestors = function _hasNoPausedAncestors(animation) {
1682    return !animation || animation._ts && _hasNoPausedAncestors(animation.parent);
1683}, _elapsedCycleDuration = function _elapsedCycleDuration(animation) {
1684    return animation._repeat ? _animationCycle(animation._tTime, animation = animation.duration() + animation._rDelay) * animation : 0;
1685}, // feed in the totalTime and cycleDuration and it'll return the cycle (iteration minus 1) and if the playhead is exactly at the very END, it will NOT bump up to the next cycle.
1686_animationCycle = function _animationCycle(tTime, cycleDuration) {
1687    var whole = Math.floor(tTime = _roundPrecise(tTime / cycleDuration));
1688    return tTime && whole === tTime ? whole - 1 : whole;
1689}, _parentToChildTotalTime = function _parentToChildTotalTime(parentTime, child) {
1690    return (parentTime - child._start) * child._ts + (child._ts >= 0 ? 0 : child._dirty ? child.totalDuration() : child._tDur);
1691}, _setEnd = function _setEnd(animation) {
1692    return animation._end = _roundPrecise(animation._start + (animation._tDur / Math.abs(animation._ts || animation._rts || _tinyNum) || 0));
1693}, _alignPlayhead = function _alignPlayhead(animation, totalTime) {
1694    // adjusts the animation's _start and _end according to the provided totalTime (only if the parent's smoothChildTiming is true and the animation isn't paused). It doesn't do any rendering or forcing things back into parent timelines, etc. - that's what totalTime() is for.
1695    var parent = animation._dp;
1696    if (parent && parent.smoothChildTiming && animation._ts) {
1697        animation._start = _roundPrecise(parent._time - (animation._ts > 0 ? totalTime / animation._ts : ((animation._dirty ? animation.totalDuration() : animation._tDur) - totalTime) / -animation._ts));
1698        _setEnd(animation);
1699        parent._dirty || _uncache(parent, animation); //for performance improvement. If the parent's cache is already dirty, it already took care of marking the ancestors as dirty too, so skip the function call here.
1700    }
1701    return animation;
1702}, /*
1703_totalTimeToTime = (clampedTotalTime, duration, repeat, repeatDelay, yoyo) => {
1704	let cycleDuration = duration + repeatDelay,
1705		time = _round(clampedTotalTime % cycleDuration);
1706	if (time > duration) {
1707		time = duration;
1708	}
1709	return (yoyo && (~~(clampedTotalTime / cycleDuration) & 1)) ? duration - time : time;
1710},
1711*/ _postAddChecks = function _postAddChecks(timeline, child) {
1712    var t;
1713    if (child._time || !child._dur && child._initted || child._start < timeline._time && (child._dur || !child.add)) {
1714        // in case, for example, the _start is moved on a tween that has already rendered, or if it's being inserted into a timeline BEFORE where the playhead is currently. Imagine it's at its end state, then the startTime is moved WAY later (after the end of this timeline), it should render at its beginning. Special case: if it's a timeline (has .add() method) and no duration, we can skip rendering because the user may be populating it AFTER adding it to a parent timeline (unconventional, but possible, and we wouldn't want it to get removed if the parent's autoRemoveChildren is true).
1715        t = _parentToChildTotalTime(timeline.rawTime(), child);
1716        if (!child._dur || _clamp(0, child.totalDuration(), t) - child._tTime > _tinyNum) child.render(t, true);
1717    } //if the timeline has already ended but the inserted tween/timeline extends the duration, we should enable this timeline again so that it renders properly. We should also align the playhead with the parent timeline's when appropriate.
1718    if (_uncache(timeline, child)._dp && timeline._initted && timeline._time >= timeline._dur && timeline._ts) {
1719        //in case any of the ancestors had completed but should now be enabled...
1720        if (timeline._dur < timeline.duration()) {
1721            t = timeline;
1722            while(t._dp){
1723                t.rawTime() >= 0 && t.totalTime(t._tTime); //moves the timeline (shifts its startTime) if necessary, and also enables it. If it's currently zero, though, it may not be scheduled to render until later so there's no need to force it to align with the current playhead position. Only move to catch up with the playhead.
1724                t = t._dp;
1725            }
1726        }
1727        timeline._zTime = -_tinyNum; // helps ensure that the next render() will be forced (crossingStart = true in render()), even if the duration hasn't changed (we're adding a child which would need to get rendered). Definitely an edge case. Note: we MUST do this AFTER the loop above where the totalTime() might trigger a render() because this _addToTimeline() method gets called from the Animation constructor, BEFORE tweens even record their targets, etc. so we wouldn't want things to get triggered in the wrong order.
1728    }
1729}, _addToTimeline = function _addToTimeline(timeline, child, position, skipChecks) {
1730    child.parent && _removeFromParent(child);
1731    child._start = _roundPrecise((_isNumber(position) ? position : position || timeline !== _globalTimeline ? _parsePosition(timeline, position, child) : timeline._time) + child._delay);
1732    child._end = _roundPrecise(child._start + (child.totalDuration() / Math.abs(child.timeScale()) || 0));
1733    _addLinkedListItem(timeline, child, "_first", "_last", timeline._sort ? "_start" : 0);
1734    _isFromOrFromStart(child) || (timeline._recent = child);
1735    skipChecks || _postAddChecks(timeline, child);
1736    timeline._ts < 0 && _alignPlayhead(timeline, timeline._tTime); // if the timeline is reversed and the new child makes it longer, we may need to adjust the parent's _start (push it back)
1737    return timeline;
1738}, _scrollTrigger = function _scrollTrigger(animation, trigger) {
1739    return (_globals.ScrollTrigger || _missingPlugin("scrollTrigger", trigger)) && _globals.ScrollTrigger.create(trigger, animation);
1740}, _attemptInitTween = function _attemptInitTween(tween, time, force, suppressEvents, tTime) {
1741    _initTween(tween, time, tTime);
1742    if (!tween._initted) return 1;
1743    if (!force && tween._pt && !_reverting && (tween._dur && tween.vars.lazy !== false || !tween._dur && tween.vars.lazy) && _lastRenderedFrame !== _ticker.frame) {
1744        _lazyTweens.push(tween);
1745        tween._lazy = [
1746            tTime,
1747            suppressEvents
1748        ];
1749        return 1;
1750    }
1751}, _parentPlayheadIsBeforeStart = function _parentPlayheadIsBeforeStart(_ref) {
1752    var parent = _ref.parent;
1753    return parent && parent._ts && parent._initted && !parent._lock && (parent.rawTime() < 0 || _parentPlayheadIsBeforeStart(parent));
1754}, // check parent's _lock because when a timeline repeats/yoyos and does its artificial wrapping, we shouldn't force the ratio back to 0
1755_isFromOrFromStart = function _isFromOrFromStart(_ref2) {
1756    var data = _ref2.data;
1757    return data === "isFromStart" || data === "isStart";
1758}, _renderZeroDurationTween = function _renderZeroDurationTween(tween, totalTime, suppressEvents, force) {
1759    var prevRatio = tween.ratio, ratio = totalTime < 0 || !totalTime && (!tween._start && _parentPlayheadIsBeforeStart(tween) && !(!tween._initted && _isFromOrFromStart(tween)) || (tween._ts < 0 || tween._dp._ts < 0) && !_isFromOrFromStart(tween)) ? 0 : 1, // if the tween or its parent is reversed and the totalTime is 0, we should go to a ratio of 0. Edge case: if a from() or fromTo() stagger tween is placed later in a timeline, the "startAt" zero-duration tween could initially render at a time when the parent timeline's playhead is technically BEFORE where this tween is, so make sure that any "from" and "fromTo" startAt tweens are rendered the first time at a ratio of 1.
1760    repeatDelay = tween._rDelay, tTime = 0, pt, iteration, prevIteration;
1761    if (repeatDelay && tween._repeat) {
1762        // in case there's a zero-duration tween that has a repeat with a repeatDelay
1763        tTime = _clamp(0, tween._tDur, totalTime);
1764        iteration = _animationCycle(tTime, repeatDelay);
1765        tween._yoyo && iteration & 1 && (ratio = 1 - ratio);
1766        if (iteration !== _animationCycle(tween._tTime, repeatDelay)) {
1767            // if iteration changed
1768            prevRatio = 1 - ratio;
1769            tween.vars.repeatRefresh && tween._initted && tween.invalidate();
1770        }
1771    }
1772    if (ratio !== prevRatio || _reverting || force || tween._zTime === _tinyNum || !totalTime && tween._zTime) {
1773        if (!tween._initted && _attemptInitTween(tween, totalTime, force, suppressEvents, tTime)) // if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately.
1774        return;
1775        prevIteration = tween._zTime;
1776        tween._zTime = totalTime || (suppressEvents ? _tinyNum : 0); // when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect.
1777        suppressEvents || (suppressEvents = totalTime && !prevIteration); // if it was rendered previously at exactly 0 (_zTime) and now the playhead is moving away, DON'T fire callbacks otherwise they'll seem like duplicates.
1778        tween.ratio = ratio;
1779        tween._from && (ratio = 1 - ratio);
1780        tween._time = 0;
1781        tween._tTime = tTime;
1782        pt = tween._pt;
1783        while(pt){
1784            pt.r(ratio, pt.d);
1785            pt = pt._next;
1786        }
1787        totalTime < 0 && _rewindStartAt(tween, totalTime, suppressEvents, true);
1788        tween._onUpdate && !suppressEvents && _callback(tween, "onUpdate");
1789        tTime && tween._repeat && !suppressEvents && tween.parent && _callback(tween, "onRepeat");
1790        if ((totalTime >= tween._tDur || totalTime < 0) && tween.ratio === ratio) {
1791            ratio && _removeFromParent(tween, 1);
1792            if (!suppressEvents && !_reverting) {
1793                _callback(tween, ratio ? "onComplete" : "onReverseComplete", true);
1794                tween._prom && tween._prom();
1795            }
1796        }
1797    } else if (!tween._zTime) tween._zTime = totalTime;
1798}, _findNextPauseTween = function _findNextPauseTween(animation, prevTime, time) {
1799    var child;
1800    if (time > prevTime) {
1801        child = animation._first;
1802        while(child && child._start <= time){
1803            if (child.data === "isPause" && child._start > prevTime) return child;
1804            child = child._next;
1805        }
1806    } else {
1807        child = animation._last;
1808        while(child && child._start >= time){
1809            if (child.data === "isPause" && child._start < prevTime) return child;
1810            child = child._prev;
1811        }
1812    }
1813}, _setDuration = function _setDuration(animation, duration, skipUncache, leavePlayhead) {
1814    var repeat = animation._repeat, dur = _roundPrecise(duration) || 0, totalProgress = animation._tTime / animation._tDur;
1815    totalProgress && !leavePlayhead && (animation._time *= dur / animation._dur);
1816    animation._dur = dur;
1817    animation._tDur = !repeat ? dur : repeat < 0 ? 1e10 : _roundPrecise(dur * (repeat + 1) + animation._rDelay * repeat);
1818    totalProgress > 0 && !leavePlayhead && _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress);
1819    animation.parent && _setEnd(animation);
1820    skipUncache || _uncache(animation.parent, animation);
1821    return animation;
1822}, _onUpdateTotalDuration = function _onUpdateTotalDuration(animation) {
1823    return animation instanceof Timeline ? _uncache(animation) : _setDuration(animation, animation._dur);
1824}, _zeroPosition = {
1825    _start: 0,
1826    endTime: _emptyFunc,
1827    totalDuration: _emptyFunc
1828}, _parsePosition = function _parsePosition(animation, position, percentAnimation) {
1829    var labels = animation.labels, recent = animation._recent || _zeroPosition, clippedDuration = animation.duration() >= _bigNum ? recent.endTime(false) : animation._dur, //in case there's a child that infinitely repeats, users almost never intend for the insertion point of a new child to be based on a SUPER long value like that so we clip it and assume the most recently-added child's endTime should be used instead.
1830    i, offset, isPercent;
1831    if (_isString(position) && (isNaN(position) || position in labels)) {
1832        //if the string is a number like "1", check to see if there's a label with that name, otherwise interpret it as a number (absolute value).
1833        offset = position.charAt(0);
1834        isPercent = position.substr(-1) === "%";
1835        i = position.indexOf("=");
1836        if (offset === "<" || offset === ">") {
1837            i >= 0 && (position = position.replace(/=/, ""));
1838            return (offset === "<" ? recent._start : recent.endTime(recent._repeat >= 0)) + (parseFloat(position.substr(1)) || 0) * (isPercent ? (i < 0 ? recent : percentAnimation).totalDuration() / 100 : 1);
1839        }
1840        if (i < 0) {
1841            position in labels || (labels[position] = clippedDuration);
1842            return labels[position];
1843        }
1844        offset = parseFloat(position.charAt(i - 1) + position.substr(i + 1));
1845        if (isPercent && percentAnimation) offset = offset / 100 * (_isArray(percentAnimation) ? percentAnimation[0] : percentAnimation).totalDuration();
1846        return i > 1 ? _parsePosition(animation, position.substr(0, i - 1), percentAnimation) + offset : clippedDuration + offset;
1847    }
1848    return position == null ? clippedDuration : +position;
1849}, _createTweenType = function _createTweenType(type, params, timeline) {
1850    var isLegacy = _isNumber(params[1]), varsIndex = (isLegacy ? 2 : 1) + (type < 2 ? 0 : 1), vars = params[varsIndex], irVars, parent;
1851    isLegacy && (vars.duration = params[1]);
1852    vars.parent = timeline;
1853    if (type) {
1854        irVars = vars;
1855        parent = timeline;
1856        while(parent && !("immediateRender" in irVars)){
1857            // inheritance hasn't happened yet, but someone may have set a default in an ancestor timeline. We could do vars.immediateRender = _isNotFalse(_inheritDefaults(vars).immediateRender) but that'd exact a slight performance penalty because _inheritDefaults() also runs in the Tween constructor. We're paying a small kb price here to gain speed.
1858            irVars = parent.vars.defaults || {};
1859            parent = _isNotFalse(parent.vars.inherit) && parent.parent;
1860        }
1861        vars.immediateRender = _isNotFalse(irVars.immediateRender);
1862        type < 2 ? vars.runBackwards = 1 : vars.startAt = params[varsIndex - 1]; // "from" vars
1863    }
1864    return new Tween(params[0], vars, params[varsIndex + 1]);
1865}, _conditionalReturn = function _conditionalReturn(value, func) {
1866    return value || value === 0 ? func(value) : func;
1867}, _clamp = function _clamp(min, max, value) {
1868    return value < min ? min : value > max ? max : value;
1869}, getUnit = function getUnit(value, v) {
1870    return !_isString(value) || !(v = _unitExp.exec(value)) ? "" : v[1];
1871}, // note: protect against padded numbers as strings, like "100.100". That shouldn't return "00" as the unit. If it's numeric, return no unit.
1872clamp = function clamp(min, max, value) {
1873    return _conditionalReturn(value, function(v) {
1874        return _clamp(min, max, v);
1875    });
1876}, _slice = [].slice, _isArrayLike = function _isArrayLike(value, nonEmpty) {
1877    return value && _isObject(value) && "length" in value && (!nonEmpty && !value.length || value.length - 1 in value && _isObject(value[0])) && !value.nodeType && value !== _win;
1878}, _flatten = function _flatten(ar, leaveStrings, accumulator) {
1879    if (accumulator === void 0) accumulator = [];
1880    return ar.forEach(function(value) {
1881        var _accumulator;
1882        return _isString(value) && !leaveStrings || _isArrayLike(value, 1) ? (_accumulator = accumulator).push.apply(_accumulator, toArray(value)) : accumulator.push(value);
1883    }) || accumulator;
1884}, //takes any value and returns an array. If it's a string (and leaveStrings isn't true), it'll use document.querySelectorAll() and convert that to an array. It'll also accept iterables like jQuery objects.
1885toArray = function toArray(value, scope, leaveStrings) {
1886    return _context && !scope && _context.selector ? _context.selector(value) : _isString(value) && !leaveStrings && (_coreInitted || !_wake()) ? _slice.call((scope || _doc).querySelectorAll(value), 0) : _isArray(value) ? _flatten(value, leaveStrings) : _isArrayLike(value) ? _slice.call(value, 0) : value ? [
1887        value
1888    ] : [];
1889}, selector = function selector(value) {
1890    value = toArray(value)[0] || _warn("Invalid scope") || {};
1891    return function(v) {
1892        var el = value.current || value.nativeElement || value;
1893        return toArray(v, el.querySelectorAll ? el : el === value ? _warn("Invalid scope") || _doc.createElement("div") : value);
1894    };
1895}, shuffle = function shuffle(a) {
1896    return a.sort(function() {
1897        return .5 - Math.random();
1898    });
1899}, // alternative that's a bit faster and more reliably diverse but bigger:   for (let j, v, i = a.length; i; j = (Math.random() * i) | 0, v = a[--i], a[i] = a[j], a[j] = v); return a;
1900//for distributing values across an array. Can accept a number, a function or (most commonly) a function which can contain the following properties: {base, amount, from, ease, grid, axis, length, each}. Returns a function that expects the following parameters: index, target, array. Recognizes the following
1901distribute = function distribute(v) {
1902    if (_isFunction(v)) return v;
1903    var vars = _isObject(v) ? v : {
1904        each: v
1905    }, //n:1 is just to indicate v was a number; we leverage that later to set v according to the length we get. If a number is passed in, we treat it like the old stagger value where 0.1, for example, would mean that things would be distributed with 0.1 between each element in the array rather than a total "amount" that's chunked out among them all.
1906    ease = _parseEase(vars.ease), from = vars.from || 0, base = parseFloat(vars.base) || 0, cache = {}, isDecimal = from > 0 && from < 1, ratios = isNaN(from) || isDecimal, axis = vars.axis, ratioX = from, ratioY = from;
1907    if (_isString(from)) ratioX = ratioY = ({
1908        center: .5,
1909        edges: .5,
1910        end: 1
1911    })[from] || 0;
1912    else if (!isDecimal && ratios) {
1913        ratioX = from[0];
1914        ratioY = from[1];
1915    }
1916    return function(i, target, a) {
1917        var l = (a || vars).length, distances = cache[l], originX, originY, x, y, d, j, max, min, wrapAt;
1918        if (!distances) {
1919            wrapAt = vars.grid === "auto" ? 0 : (vars.grid || [
1920                1,
1921                _bigNum
1922            ])[1];
1923            if (!wrapAt) {
1924                max = -_bigNum;
1925                while(max < (max = a[wrapAt++].getBoundingClientRect().left) && wrapAt < l);
1926                wrapAt < l && wrapAt--;
1927            }
1928            distances = cache[l] = [];
1929            originX = ratios ? Math.min(wrapAt, l) * ratioX - .5 : from % wrapAt;
1930            originY = wrapAt === _bigNum ? 0 : ratios ? l * ratioY / wrapAt - .5 : from / wrapAt | 0;
1931            max = 0;
1932            min = _bigNum;
1933            for(j = 0; j < l; j++){
1934                x = j % wrapAt - originX;
1935                y = originY - (j / wrapAt | 0);
1936                distances[j] = d = !axis ? _sqrt(x * x + y * y) : Math.abs(axis === "y" ? y : x);
1937                d > max && (max = d);
1938                d < min && (min = d);
1939            }
1940            from === "random" && shuffle(distances);
1941            distances.max = max - min;
1942            distances.min = min;
1943            distances.v = l = (parseFloat(vars.amount) || parseFloat(vars.each) * (wrapAt > l ? l - 1 : !axis ? Math.max(wrapAt, l / wrapAt) : axis === "y" ? l / wrapAt : wrapAt) || 0) * (from === "edges" ? -1 : 1);
1944            distances.b = l < 0 ? base - l : base;
1945            distances.u = getUnit(vars.amount || vars.each) || 0; //unit
1946            ease = ease && l < 0 ? _invertEase(ease) : ease;
1947        }
1948        l = (distances[i] - distances.min) / distances.max || 0;
1949        return _roundPrecise(distances.b + (ease ? ease(l) : l) * distances.v) + distances.u; //round in order to work around floating point errors
1950    };
1951}, _roundModifier = function _roundModifier(v) {
1952    //pass in 0.1 get a function that'll round to the nearest tenth, or 5 to round to the closest 5, or 0.001 to the closest 1000th, etc.
1953    var p = Math.pow(10, ((v + "").split(".")[1] || "").length); //to avoid floating point math errors (like 24 * 0.1 == 2.4000000000000004), we chop off at a specific number of decimal places (much faster than toFixed())
1954    return function(raw) {
1955        var n = _roundPrecise(Math.round(parseFloat(raw) / v) * v * p);
1956        return (n - n % 1) / p + (_isNumber(raw) ? 0 : getUnit(raw)); // n - n % 1 replaces Math.floor() in order to handle negative values properly. For example, Math.floor(-150.00000000000003) is 151!
1957    };
1958}, snap = function snap(snapTo, value) {
1959    var isArray = _isArray(snapTo), radius, is2D;
1960    if (!isArray && _isObject(snapTo)) {
1961        radius = isArray = snapTo.radius || _bigNum;
1962        if (snapTo.values) {
1963            snapTo = toArray(snapTo.values);

1964            if (is2D = !_isNumber(snapTo[0])) radius *= radius; //performance optimization so we don't have to Math.sqrt() in the loop.
1965        } else snapTo = _roundModifier(snapTo.increment);
1966    }
1967    return _conditionalReturn(value, !isArray ? _roundModifier(snapTo) : _isFunction(snapTo) ? function(raw) {
1968        is2D = snapTo(raw);
1969        return Math.abs(is2D - raw) <= radius ? is2D : raw;
1970    } : function(raw) {
1971        var x = parseFloat(is2D ? raw.x : raw), y = parseFloat(is2D ? raw.y : 0), min = _bigNum, closest = 0, i = snapTo.length, dx, dy;
1972        while(i--){
1973            if (is2D) {
1974                dx = snapTo[i].x - x;
1975                dy = snapTo[i].y - y;
1976                dx = dx * dx + dy * dy;
1977            } else dx = Math.abs(snapTo[i] - x);
1978            if (dx < min) {
1979                min = dx;
1980                closest = i;
1981            }
1982        }
1983        closest = !radius || min <= radius ? snapTo[closest] : raw;
1984        return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
1985    });
1986}, random = function random(min, max, roundingIncrement, returnFunction) {
1987    return _conditionalReturn(_isArray(min) ? !max : roundingIncrement === true ? (roundingIncrement = 0, false) : !returnFunction, function() {
1988        return _isArray(min) ? min[~~(Math.random() * min.length)] : (roundingIncrement = roundingIncrement || 1e-5, returnFunction = roundingIncrement < 1 ? Math.pow(10, (roundingIncrement + "").length - 2) : 1) && Math.floor(Math.round((min - roundingIncrement / 2 + Math.random() * (max - min + roundingIncrement * .99)) / roundingIncrement) * roundingIncrement * returnFunction) / returnFunction;
1989    });
1990}, pipe = function pipe() {
1991    for(var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++)functions[_key] = arguments[_key];
1992    return function(value) {
1993        return functions.reduce(function(v, f) {
1994            return f(v);
1995        }, value);
1996    };
1997}, unitize = function unitize(func, unit) {
1998    return function(value) {
1999        return func(parseFloat(value)) + (unit || getUnit(value));
2000    };
2001}, normalize = function normalize(min, max, value) {
2002    return mapRange(min, max, 0, 1, value);
2003}, _wrapArray = function _wrapArray(a, wrapper, value) {
2004    return _conditionalReturn(value, function(index) {
2005        return a[~~wrapper(index)];
2006    });
2007}, wrap = function wrap(min, max, value) {
2008    // NOTE: wrap() CANNOT be an arrow function! A very odd compiling bug causes problems (unrelated to GSAP).
2009    var range = max - min;
2010    return _isArray(min) ? _wrapArray(min, wrap(0, min.length), max) : _conditionalReturn(value, function(value) {
2011        return (range + (value - min) % range) % range + min;
2012    });
2013}, wrapYoyo = function wrapYoyo(min, max, value) {
2014    var range = max - min, total = range * 2;
2015    return _isArray(min) ? _wrapArray(min, wrapYoyo(0, min.length - 1), max) : _conditionalReturn(value, function(value) {
2016        value = (total + (value - min) % total) % total || 0;
2017        return min + (value > range ? total - value : value);
2018    });
2019}, _replaceRandom = function _replaceRandom(value) {
2020    //replaces all occurrences of random(...) in a string with the calculated random value. can be a range like random(-100, 100, 5) or an array like random([0, 100, 500])
2021    var prev = 0, s = "", i, nums, end, isArray;
2022    while(~(i = value.indexOf("random(", prev))){
2023        end = value.indexOf(")", i);
2024        isArray = value.charAt(i + 7) === "[";
2025        nums = value.substr(i + 7, end - i - 7).match(isArray ? _delimitedValueExp : _strictNumExp);
2026        s += value.substr(prev, i - prev) + random(isArray ? nums : +nums[0], isArray ? 0 : +nums[1], +nums[2] || 1e-5);
2027        prev = end + 1;
2028    }
2029    return s + value.substr(prev, value.length - prev);
2030}, mapRange = function mapRange(inMin, inMax, outMin, outMax, value) {
2031    var inRange = inMax - inMin, outRange = outMax - outMin;
2032    return _conditionalReturn(value, function(value) {
2033        return outMin + ((value - inMin) / inRange * outRange || 0);
2034    });
2035}, interpolate = function interpolate(start, end, progress, mutate) {
2036    var func = isNaN(start + end) ? 0 : function(p) {
2037        return (1 - p) * start + p * end;
2038    };
2039    if (!func) {
2040        var isString = _isString(start), master = {}, p, i, interpolators, l, il;
2041        progress === true && (mutate = 1) && (progress = null);
2042        if (isString) {
2043            start = {
2044                p: start
2045            };
2046            end = {
2047                p: end
2048            };
2049        } else if (_isArray(start) && !_isArray(end)) {
2050            interpolators = [];
2051            l = start.length;
2052            il = l - 2;
2053            for(i = 1; i < l; i++)interpolators.push(interpolate(start[i - 1], start[i])); //build the interpolators up front as a performance optimization so that when the function is called many times, it can just reuse them.
2054            l--;
2055            func = function func(p) {
2056                p *= l;
2057                var i = Math.min(il, ~~p);
2058                return interpolators[i](p - i);
2059            };
2060            progress = end;
2061        }

2061 else if (!mutate) start = _merge(_isArray(start) ? [] : {}, start);
2062        if (!interpolators) {
2063            for(p in end)_addPropTween.call(master, start, p, "get", end[p]);
2064            func = function func(p) {
2065                return _renderPropTweens(p, master) || (isString ? start.p : start);
2066            };
2067        }
2068    }
2069    return _conditionalReturn(progress, func);
2070}, _getLabelInDirection = function _getLabelInDirection(timeline, fromTime, backward) {
2071    //used for nextLabel() and previousLabel()
2072    var labels = timeline.labels, min = _bigNum, p, distance, label;
2073    for(p in labels){
2074        distance = labels[p] - fromTime;
2075        if (distance < 0 === !!backward && distance && min > (distance = Math.abs(distance))) {
2076            label = p;
2077            min = distance;
2078        }
2079    }
2080    return label;
2081}, _callback = function _callback(animation, type, executeLazyFirst) {
2082    var v = animation.vars, callback = v[type], prevContext = _context, context = animation._ctx, params, scope, result;
2083    if (!callback) return;
2084    params = v[type + "Params"];
2085    scope = v.callbackScope || animation;
2086    executeLazyFirst && _lazyTweens.length && _lazyRender(); //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values.
2087    context && (_context = context);
2088    result = params ? callback.apply(scope, params) : callback.call(scope);
2089    _context = prevContext;
2090    return result;
2091}, _interrupt = function _interrupt(animation) {
2092    _removeFromParent(animation);
2093    animation.scrollTrigger && animation.scrollTrigger.kill(!!_reverting);
2094    animation.progress() < 1 && _callback(animation, "onInterrupt");
2095    return animation;
2096}, _quickTween, _registerPluginQueue = [], _createPlugin = function _createPlugin(config) {
2097    if (!config) return;
2098    config = !config.name && config["default"] || config; // UMD packaging wraps things oddly, so for example MotionPathHelper becomes {MotionPathHelper:MotionPathHelper, default:MotionPathHelper}.
2099    if (_windowExists() || config.headless) {
2100        // edge case: some build tools may pass in a null/undefined value
2101        var name = config.name, isFunc = _isFunction(config), Plugin = name && !isFunc && config.init ? function() {
2102            this._props = [];
2103        } : config, //in case someone passes in an object that's not a plugin, like CustomEase
2104        instanceDefaults = {
2105            init: _emptyFunc,
2106            render: _renderPropTweens,
2107            add: _addPropTween,
2108            kill: _killPropTweensOf,
2109            modifier: _addPluginModifier,
2110            rawVars: 0
2111        }, statics = {
2112            targetTest: 0,
2113            get: 0,
2114            getSetter: _getSetter,
2115            aliases: {},
2116            register: 0
2117        };
2118        _wake();
2119        if (config !== Plugin) {
2120            if (_plugins[name]) return;
2121            _setDefaults(Plugin, _setDefaults(_copyExcluding(config, instanceDefaults), statics)); //static methods
2122            _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config, statics))); //instance methods
2123            _plugins[Plugin.prop = name] = Plugin;
2124            if (config.targetTest) {
2125                _harnessPlugins.push(Plugin);
2126                _reservedProps[name] = 1;
2127            }
2128            name = (name === "css" ? "CSS" : name.charAt(0).toUpperCase() + name.substr(1)) + "Plugin"; //for the global name. "motionPath" should become MotionPathPlugin
2129        }
2130        _addGlobal(name, Plugin);
2131        config.register && config.register(gsap, Plugin, PropTween);
2132    } else _registerPluginQueue.push(config);
2133}, /*
2134 * --------------------------------------------------------------------------------------
2135 * COLORS
2136 * --------------------------------------------------------------------------------------
2137 */ _255 = 255, _colorLookup = {
2138    aqua: [
2139        0,
2140        _255,
2141        _255
2142    ],
2143    lime: [
2144        0,
2145        _255,
2146        0
2147    ],
2148    silver: [
2149        192,
2150        192,
2151        192
2152    ],
2153    black: [
2154        0,
2155        0,
2156        0
2157    ],
2158    maroon: [
2159        128,
2160        0,
2161        0
2162    ],
2163    teal: [
2164        0,
2165        128,
2166        128
2167    ],
2168    blue: [
2169        0,
2170        0,
2171        _255
2172    ],
2173    navy: [
2174        0,
2175        0,
2176        128
2177    ],
2178    white: [
2179        _255,
2180        _255,
2181        _255
2182    ],
2183    olive: [
2184        128,
2185        128,
2186        0
2187    ],
2188    yellow: [
2189        _255,
2190        _255,
2191        0
2192    ],
2193    orange: [
2194        _255,
2195        165,
2196        0
2197    ],
2198    gray: [
2199        128,
2200        128,
2201        128
2202    ],
2203    purple: [
2204        128,
2205        0,
2206        128
2207    ],
2208    green: [
2209        0,
2210        128,
2211        0
2212    ],
2213    red: [
2214        _255,
2215        0,
2216        0
2217    ],
2218    pink: [
2219        _255,
2220        192,
2221        203
2222    ],
2223    cyan: [
2224        0,
2225        _255,
2226        _255
2227    ],
2228    transparent: [
2229        _255,
2230        _255,
2231        _255,
2232        0
2233    ]
2234}, // possible future idea to replace the hard-coded color name values - put this in the ticker.wake() where we set the _doc:
2235// let ctx = _doc.createElement("canvas").getContext("2d");
2236// _forEachName("aqua,lime,silver,black,maroon,teal,blue,navy,white,olive,yellow,orange,gray,purple,green,red,pink,cyan", color => {ctx.fillStyle = color; _colorLookup[color] = splitColor(ctx.fillStyle)});
2237_hue = function _hue(h, m1, m2) {
2238    h += h < 0 ? 1 : h > 1 ? -1 : 0;
2239    return (h * 6 < 1 ? m1 + (m2 - m1) * h * 6 : h < .5 ? m2 : h * 3 < 2 ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * _255 + .5 | 0;
2240}, splitColor = function splitColor(v, toHSL, forceAlpha) {
2241    var a = !v ? _colorLookup.black : _isNumber(v) ? [
2242        v >> 16,
2243        v >> 8 & _255,
2244        v & _255
2245    ] : 0, r, g, b, h, s, l, max, min, d, wasHSL;
2246    if (!a) {
2247        if (v.substr(-1) === ",") //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value.
2248        v = v.substr(0, v.length - 1);
2249        if (_colorLookup[v]) a = _colorLookup[v];
2250        else if (v.charAt(0) === "#") {
2251            if (v.length < 6) {
2252                //for shorthand like #9F0 or #9F0F (could have alpha)
2253                r = v.charAt(1);
2254                g = v.charAt(2);
2255                b = v.charAt(3);
2256                v = "#" + r + r + g + g + b + b + (v.length === 5 ? v.charAt(4) + v.charAt(4) : "");
2257            }
2258            if (v.length === 9) {
2259                // hex with alpha, like #fd5e53ff
2260                a = parseInt(v.substr(1, 6), 16);
2261                return [
2262                    a >> 16,
2263                    a >> 8 & _255,
2264                    a & _255,
2265                    parseInt(v.substr(7), 16) / 255
2266                ];
2267            }
2268            v = parseInt(v.substr(1), 16);
2269            a = [
2270                v >> 16,
2271                v >> 8 & _255,
2272                v & _255
2273            ];
2274        } else if (v.substr(0, 3) === "hsl") {
2275            a = wasHSL = v.match(_strictNumExp);
2276            if (!toHSL) {
2277                h = +a[0] % 360 / 360;
2278                s = +a[1] / 100;
2279                l = +a[2] / 100;
2280                g = l <= .5 ? l * (s + 1) : l + s - l * s;
2281                r = l * 2 - g;
2282                a.length > 3 && (a[3] *= 1); //cast as number
2283                a[0] = _hue(h + 1 / 3, r, g);
2284                a[1] = _hue(h, r, g);
2285                a[2] = _hue(h - 1 / 3, r, g);
2286            } else if (~v.indexOf("=")) {
2287                //if relative values are found, just return the raw strings with the relative prefixes in place.
2288                a = v.match(_numExp);
2289                forceAlpha && a.length < 4 && (a[3] = 1);
2290                return a;
2291            }
2292        } else a = v.match(_strictNumExp) || _colorLookup.transparent;
2293        a = a.map(Number);
2294    }
2295    if (toHSL && !wasHSL) {
2296        r = a[0] / _255;
2297        g = a[1] / _255;
2298        b = a[2] / _255;
2299        max = Math.max(r, g, b);
2300        min = Math.min(r, g, b);
2301        l = (max + min) / 2;
2302        if (max === min) h = s = 0;
2303        else {
2304            d = max - min;
2305            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
2306            h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
2307            h *= 60;
2308        }
2309        a[0] = ~~(h + .5);
2310        a[1] = ~~(s * 100 + .5);
2311        a[2] = ~~(l * 100 + .5);
2312    }
2313    forceAlpha && a.length < 4 && (a[3] = 1);
2314    return a;
2315}, _colorOrderData = function _colorOrderData(v) {
2316    // strips out the colors from the string, finds all the numeric slots (with units) and returns an array of those. The Array also has a "c" property which is an Array of the index values where the colors belong. This is to help work around issues where there's a mis-matched order of color/numeric data like drop-shadow(#f00 0px 1px 2px) and drop-shadow(0x 1px 2px #f00). This is basically a helper function used in _formatColors()
2317    var values = [], c = [], i = -1;
2318    v.split(_colorExp).forEach(function(v) {
2319        var a = v.match(_numWithUnitExp) || [];
2320        values.push.apply(values, a);
2321        c.push(i += a.length + 1);
2322    });
2323    values.c = c;
2324    return values;
2325}, _formatColors = function _formatColors(s, toHSL, orderMatchData) {
2326    var result = "", colors = (s + result).match(_colorExp), type = toHSL ? "hsla(" : "rgba(", i = 0, c, shell, d, l;
2327    if (!colors) return s;
2328    colors = colors.map(function(color) {
2329        return (color = splitColor(color, toHSL, 1)) && type + (toHSL ? color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : color.join(",")) + ")";
2330    });
2331    if (orderMatchData) {
2332        d = _colorOrderData(s);
2333        c = orderMatchData.c;
2334        if (c.join(result) !== d.c.join(result)) {
2335            shell = s.replace(_colorExp, "1").split(_numWithUnitExp);
2336            l = shell.length - 1;
2337            for(; i < l; i++)result += shell[i] + (~c.indexOf(i) ? colors.shift() || type + "0,0,0,0)" : (d.length ? d : colors.length ? colors : orderMatchData).shift());
2338        }
2339    }
2340    if (!shell) {
2341        shell = s.split(_colorExp);
2342        l = shell.length - 1;
2343        for(; i < l; i++)result += shell[i] + colors[i];
2344    }
2345    return result + shell[l];
2346}, _colorExp = function() {
2347    var s = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3,4}){1,2}\\b", //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc.,
2348    p;
2349    for(p in _colorLookup)s += "|" + p + "\\b";
2350    return new RegExp(s + ")", "gi");
2351}(), _hslExp = /hsl[a]?\(/, _colorStringFilter = function _colorStringFilter(a) {
2352    var combined = a.join(" "), toHSL;
2353    _colorExp.lastIndex = 0;
2354    if (_colorExp.test(combined)) {
2355        toHSL = _hslExp.test(combined);
2356        a[1] = _formatColors(a[1], toHSL);
2357        a[0] = _formatColors(a[0], toHSL, _colorOrderData(a[1])); // make sure the order of numbers/colors match with the END value.
2358        return true;
2359    }
2360}, /*
2361 * --------------------------------------------------------------------------------------
2362 * TICKER
2363 * --------------------------------------------------------------------------------------
2364 */ _tickerActive, _ticker = function() {
2365    var _getTime = Date.now, _lagThreshold = 500, _adjustedLag = 33, _startTime = _getTime(), _lastUpdate = _startTime, _gap = 1000 / 240, _nextTime = _gap, _listeners = [], _id, _req, _raf, _self, _delta, _i, _tick = function _tick(v) {
2366        var elapsed = _getTime() - _lastUpdate, manual = v === true, overlap, dispatch, time, frame;
2367        (elapsed > _lagThreshold || elapsed < 0) && (_startTime += elapsed - _adjustedLag);
2368        _lastUpdate += elapsed;
2369        time = _lastUpdate - _startTime;
2370        overlap = time - _nextTime;
2371        if (overlap > 0 || manual) {
2372            frame = ++_self.frame;
2373            _delta = time - _self.time * 1000;
2374            _self.time = time = time / 1000;
2375            _nextTime += overlap + (overlap >= _gap ? 4 : _gap - overlap);
2376            dispatch = 1;
2377        }
2378        manual || (_id = _req(_tick)); //make sure the request is made before we dispatch the "tick" event so that timing is maintained. Otherwise, if processing the "tick" requires a bunch of time (like 15ms) and we're using a setTimeout() that's based on 16.7ms, it'd technically take 31.7ms between frames otherwise.
2379        if (dispatch) for(_i = 0; _i < _listeners.length; _i++)// use _i and check _listeners.length instead of a variable because a listener could get removed during the loop, and if that happens to an element less than the current index, it'd throw things off in the loop.
2380        _listeners[_i](time, _delta, frame, v);
2381    };
2382    _self = {
2383        time: 0,
2384        frame: 0,
2385        tick: function tick() {
2386            _tick(true);
2387        },
2388        deltaRatio: function deltaRatio(fps) {
2389            return _delta / (1000 / (fps || 60));
2390        },
2391        wake: function wake() {
2392            if (_coreReady) {
2393                if (!_coreInitted && _windowExists()) {
2394                    _win = _coreInitted = window;
2395                    _doc = _win.document || {};
2396                    _globals.gsap = gsap;
2397                    (_win.gsapVersions || (_win.gsapVersions = [])).push(gsap.version);
2398                    _install(_installScope || _win.GreenSockGlobals || !_win.gsap && _win || {});
2399                    _registerPluginQueue.forEach(_createPlugin);
2400                }
2401                _raf = typeof requestAnimationFrame !== "undefined" && requestAnimationFrame;
2402                _id && _self.sleep();
2403                _req = _raf || function(f) {
2404                    return setTimeout(f, _nextTime - _self.time * 1000 + 1 | 0);
2405                };
2406                _tickerActive = 1;
2407                _tick(2);
2408            }
2409        },
2410        sleep: function sleep() {
2411            (_raf ? cancelAnimationFrame : clearTimeout)(_id);
2412            _tickerActive = 0;
2413            _req = _emptyFunc;
2414        },
2415        lagSmoothing: function lagSmoothing(threshold, adjustedLag) {
2416            _lagThreshold = threshold || Infinity; // zero should be interpreted as basically unlimited
2417            _adjustedLag = Math.min(adjustedLag || 33, _lagThreshold);
2418        },
2419        fps: function fps(_fps) {
2420            _gap = 1000 / (_fps || 240);
2421            _nextTime = _self.time * 1000 + _gap;
2422        },
2423        add: function add(callback, once, prioritize) {
2424            var func = once ? function(t, d, f, v) {
2425                callback(t, d, f, v);
2426                _self.remove(func);
2427            } : callback;
2428            _self.remove(callback);
2429            _listeners[prioritize ? "unshift" : "push"](func);
2430            _wake();
2431            return func;
2432        },
2433        remove: function remove(callback, i) {
2434            ~(i = _listeners.indexOf(callback)) && _listeners.splice(i, 1) && _i >= i && _i--;
2435        },
2436        _listeners: _listeners
2437    };
2438    return _self;
2439}(), _wake = function _wake() {
2440    return !_tickerActive && _ticker.wake();
2441}, //also ensures the core classes are initialized.
2442/*
2443* -------------------------------------------------
2444* EASING
2445* -------------------------------------------------
2446*/ _easeMap = {}, _customEaseExp = /^[\d.\-M][\d.\-,\s]/, _quotesExp = /["']/g, _parseObjectInString = function _parseObjectInString(value) {
2447    //takes a string like "{wiggles:10, type:anticipate})" and turns it into a real object. Notice it ends in ")" and includes the {} wrappers. This is because we only use this function for parsing ease configs and prioritized optimization rather than reusability.
2448    var obj = {}, split = value.substr(1, value.length - 3).split(":"), key = split[0], i = 1, l = split.length, index, val, parsedVal;
2449    for(; i < l; i++){
2450        val = split[i];
2451        index = i !== l - 1 ? val.lastIndexOf(",") : val.length;
2452        parsedVal = val.substr(0, index);
2453        obj[key] = isNaN(parsedVal) ? parsedVal.replace(_quotesExp, "").trim() : +parsedVal;
2454        key = val.substr(index + 1).trim();
2455    }
2456    return obj;
2457}, _valueInParentheses = function _valueInParentheses(value) {
2458    var open = value.indexOf("(") + 1, close = value.indexOf(")"), nested = value.indexOf("(", open

2458);
2459    return value.substring(open, ~nested && nested < close ? value.indexOf(")", close + 1) : close);
2460}, _configEaseFromString = function _configEaseFromString(name) {
2461    //name can be a string like "elastic.out(1,0.5)", and pass in _easeMap as obj and it'll parse it out and call the actual function like _easeMap.Elastic.easeOut.config(1,0.5). It will also parse custom ease strings as long as CustomEase is loaded and registered (internally as _easeMap._CE).
2462    var split = (name + "").split("("), ease = _easeMap[split[0]];
2463    return ease && split.length > 1 && ease.config ? ease.config.apply(null, ~name.indexOf("{") ? [
2464        _parseObjectInString(split[1])
2465    ] : _valueInParentheses(name).split(",").map(_numericIfPossible)) : _easeMap._CE && _customEaseExp.test(name) ? _easeMap._CE("", name) : ease;
2466}, _invertEase = function _invertEase(ease) {
2467    return function(p) {
2468        return 1 - ease(1 - p);
2469    };
2470}, // allow yoyoEase to be set in children and have those affected when the parent/ancestor timeline yoyos.
2471_propagateYoyoEase = function _propagateYoyoEase(timeline, isYoyo) {
2472    var child = timeline._first, ease;
2473    while(child){
2474        if (child instanceof Timeline) _propagateYoyoEase(child, isYoyo);
2475        else if (child.vars.yoyoEase && (!child._yoyo || !child._repeat) && child._yoyo !== isYoyo) {
2476            if (child.timeline) _propagateYoyoEase(child.timeline, isYoyo);
2477            else {
2478                ease = child._ease;
2479                child._ease = child._yEase;
2480                child._yEase = ease;
2481                child._yoyo = isYoyo;
2482            }
2483        }
2484        child = child._next;
2485    }
2486}, _parseEase = function _parseEase(ease, defaultEase) {
2487    return !ease ? defaultEase : (_isFunction(ease) ? ease : _easeMap[ease] || _configEaseFromString(ease)) || defaultEase;
2488}, _insertEase = function _insertEase(names, easeIn, easeOut, easeInOut) {
2489    if (easeOut === void 0) easeOut = function easeOut(p) {
2490        return 1 - easeIn(1 - p);
2491    };
2492    if (easeInOut === void 0) easeInOut = function easeInOut(p) {
2493        return p < .5 ? easeIn(p * 2) / 2 : 1 - easeIn((1 - p) * 2) / 2;
2494    };
2495    var ease = {
2496        easeIn: easeIn,
2497        easeOut: easeOut,
2498        easeInOut: easeInOut
2499    }, lowercaseName;
2500    _forEachName(names, function(name) {
2501        _easeMap[name] = _globals[name] = ease;
2502        _easeMap[lowercaseName = name.toLowerCase()] = easeOut;
2503        for(var p in ease)_easeMap[lowercaseName + (p === "easeIn" ? ".in" : p === "easeOut" ? ".out" : ".inOut")] = _easeMap[name + "." + p] = ease[p];
2504    });
2505    return ease;
2506}, _easeInOutFromOut = function _easeInOutFromOut(easeOut) {
2507    return function(p) {
2508        return p < .5 ? (1 - easeOut(1 - p * 2)) / 2 : .5 + easeOut((p - .5) * 2) / 2;
2509    };
2510}, _configElastic = function _configElastic(type, amplitude, period) {
2511    var p1 = amplitude >= 1 ? amplitude : 1, //note: if amplitude is < 1, we simply adjust the period for a more natural feel. Otherwise the math doesn't work right and the curve starts at 1.
2512    p2 = (period || (type ? .3 : .45)) / (amplitude < 1 ? amplitude : 1), p3 = p2 / _2PI * (Math.asin(1 / p1) || 0), easeOut = function easeOut(p) {
2513        return p === 1 ? 1 : p1 * Math.pow(2, -10 * p) * _sin((p - p3) * p2) + 1;
2514    }, ease = type === "out" ? easeOut : type === "in" ? function(p) {
2515        return 1 - easeOut(1 - p);
2516    } : _easeInOutFromOut(easeOut);
2517    p2 = _2PI / p2; //precalculate to optimize
2518    ease.config = function(amplitude, period) {
2519        return _configElastic(type, amplitude, period);
2520    };
2521    return ease;
2522}, _configBack = function _configBack(type, overshoot) {
2523    if (overshoot === void 0) overshoot = 1.70158;
2524    var easeOut = function easeOut(p) {
2525        return p ? --p * p * ((overshoot + 1) * p + overshoot) + 1 : 0;
2526    }, ease = type === "out" ? easeOut : type === "in" ? function(p) {
2527        return 1 - easeOut(1 - p);
2528    } : _easeInOutFromOut(easeOut);
2529    ease.config = function(overshoot) {
2530        return _configBack(type, overshoot);
2531    };
2532    return ease;
2533}; // a cheaper (kb and cpu) but more mild way to get a parameterized weighted ease by feeding in a value between -1 (easeIn) and 1 (easeOut) where 0 is linear.
2534// _weightedEase = ratio => {
2535// 	let y = 0.5 + ratio / 2;
2536// 	return p => (2 * (1 - p) * p * y + p * p);
2537// },
2538// a stronger (but more expensive kb/cpu) parameterized weighted ease that lets you feed in a value between -1 (easeIn) and 1 (easeOut) where 0 is linear.
2539// _weightedEaseStrong = ratio => {
2540// 	ratio = .5 + ratio / 2;
2541// 	let o = 1 / 3 * (ratio < .5 ? ratio : 1 - ratio),
2542// 		b = ratio - o,
2543// 		c = ratio + o;
2544// 	return p => p === 1 ? p : 3 * b * (1 - p) * (1 - p) * p + 3 * c * (1 - p) * p * p + p * p * p;
2545// };
2546_forEachName("Linear,Quad,Cubic,Quart,Quint,Strong", function(name, i) {
2547    var power = i < 5 ? i + 1 : i;
2548    _insertEase(name + ",Power" + (power - 1), i ? function(p) {
2549        return Math.pow(p, power);
2550    } : function(p) {
2551        return p;
2552    }, function(p) {
2553        return 1 - Math.pow(1 - p, power);
2554    }, function(p) {
2555        return p < .5 ? Math.pow(p * 2, power) / 2 : 1 - Math.pow((1 - p) * 2, power) / 2;
2556    });
2557});
2558_easeMap.Linear.easeNone = _easeMap.none = _easeMap.Linear.easeIn;

2559_insertEase("Elastic", _configElastic("in"), _configElastic("out"), _configElastic());
2560(function(n, c) {
2561    var n1 = 1 / c, n2 = 2 * n1, n3 = 2.5 * n1, easeOut = function easeOut(p) {
2562        return p < n1 ? n * p * p : p < n2 ? n * Math.pow(p - 1.5 / c, 2) + .75 : p < n3 ? n * (p -= 2.25 / c) * p + .9375 : n * Math.pow(p - 2.625 / c, 2) + .984375;
2563    };
2564    _insertEase("Bounce", function(p) {
2565        return 1 - easeOut(1 - p);
2566    }, easeOut);
2567})(7.5625, 2.75);
2568_insertEase("Expo", function(p) {
2569    return Math.pow(2, 10 * (p - 1)) * p + p * p * p * p * p * p * (1 - p);
2570}); // previously 2 ** (10 * (p - 1)) but that doesn't end up with the value quite at the right spot so we do a blended ease to ensure it lands where it should perfectly.
2571_insertEase("Circ", function(p) {
2572    return -(_sqrt(1 - p * p) - 1);
2573});
2574_insertEase("Sine", function(p) {
2575    return p === 1 ? 1 : -_cos(p * _HALF_PI) + 1;
2576});
2577_insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
2578_easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
2579    config: function config(steps, immediateStart) {
2580        if (steps === void 0) steps = 1;
2581        var p1 = 1 / steps, p2 = steps + (immediateStart ? 0 : 1), p3 = immediateStart ? 1 : 0, max = 1 - _tinyNum;
2582        return function(p) {
2583            return ((p2 * _clamp(0, max, p) | 0) + p3) * p1;
2584        };
2585    }
2586};
2587_defaults.ease = _easeMap["quad.out"];
2588_forEachName("onComplete,onUpdate,onStart,onRepeat,onReverseComplete,onInterrupt", function(name) {
2589    return _callbackNames += name + "," + name + "Params,";
2590});
2591var GSCache = function GSCache(target, harness) {
2592    this.id = _gsID++;
2593    target._gsap = this;
2594    this.target = target;
2595    this.harness = harness;
2596    this.get = harness ? harness.get : _getProperty;
2597    this.set = harness ? harness.getSetter : _getSetter;
2598};
2599var Animation = /*#__PURE__*/ function() {
2600    function Animation(vars) {
2601        this.vars = vars;
2602        this._delay = +vars.delay || 0;
2603        if (this._repeat = vars.repeat === Infinity ? -2 : vars.repeat || 0) {
2604            // TODO: repeat: Infinity on a timeline's children must flag that timeline internally and affect its totalDuration, otherwise it'll stop in the negative direction when reaching the start.
2605            this._rDelay = vars.repeatDelay || 0;
2606            this._yoyo = !!vars.yoyo || !!vars.yoyoEase;
2607        }
2608        this._ts = 1;
2609        _setDuration(this, +vars.duration, 1, 1);
2610        this.data = vars.data;
2611        if (_context) {
2612            this._ctx = _context;
2613            _context.data.push(this);
2614        }
2615        _tickerActive || _ticker.wake();
2616    }
2617    var _proto = Animation.prototype;
2618    _proto.delay = function delay(value) {
2619        if (value || value === 0) {
2620            this.parent && this.parent.smoothChildTiming && this.startTime(this._start + value - this._delay);
2621            this._delay = value;
2622            return this;
2623        }
2624        return this._delay;
2625    };
2626    _proto.duration = function duration(value) {
2627        return arguments.length ? this.totalDuration(this._repeat > 0 ? value + (value + this._rDelay) * this._repeat : value) : this.totalDuration() && this._dur;
2628    };
2629    _proto.totalDuration = function totalDuration(value) {
2630        if (!arguments.length) return this._tDur;
2631        this._dirty = 0;
2632        return _setDuration(this, this._repeat < 0 ? value : (value - this._repeat * this._rDelay) / (this._repeat + 1));
2633    };
2634    _proto.totalTime = function totalTime(_totalTime, suppressEvents) {
2635        _wake();
2636        if (!arguments.length) return this._tTime;
2637        var parent = this._dp;
2638        if (parent && parent.smoothChildTiming && this._ts) {
2639            _alignPlayhead(this, _totalTime);
2640            !parent._dp || parent.parent || _postAddChecks(parent, this); // edge case: if this is a child of a timeline that already completed, for example, we must re-activate the parent.
2641            //in case any of the ancestor timelines had completed but should now be enabled, we should reset their totalTime() which will also ensure that they're lined up properly and enabled. Skip for animations that are on the root (wasteful). Example: a TimelineLite.exportRoot() is performed when there's a paused tween on the root, the export will not complete until that tween is unpaused, but imagine a child gets restarted later, after all [unpaused] tweens have completed. The start of that child would get pushed out, but one of the ancestors may have completed.
2642            while(parent && parent.parent){
2643                if (parent.parent._time !== parent._start + (parent._ts >= 0 ? parent._tTime / parent._ts : (parent.totalDuration() - parent._tTime) / -parent._ts)) parent.totalTime(parent._tTime, true);
2644                parent = parent.parent;
2645            }
2646            if (!this.parent && this._dp.autoRemoveChildren && (this._ts > 0 && _totalTime < this._tDur || this._ts < 0 && _totalTime > 0 || !this._tDur && !_totalTime)) //if the animation doesn't have a parent, put it back into its last parent (recorded as _dp for exactly cases like this). Limit to parents with autoRemoveChildren (like globalTimeline) so that if the user manually removes an animation from a timeline and then alters its playhead, it doesn't get added back in.