{"version":3,"sources":["webpack:///./node_modules/@ionic/core/dist/esm-es5/index-69c37885.js"],"names":["transitionEnd","el","callback","unregister","unRegTrans","onTransitionEnd","ev","target","opts","passive","addEventListener","removeEventListener","CSS_VALUE_REGEX","TRANSFORM_PROPS","win","window","raf","requestAnimationFrame","bind","f","Date","now","Animator","prototype","addElement","length","i","this","_addEl","nodeType","_elements","push","add","childAnimation","parent","hasChildren","_childAnimations","getDuration","undefined","duration","_duration","isRoot","milliseconds","getEasing","_isReverse","_reversedEasingName","_easingName","easing","name","easingReverse","from","prop","val","_addProp","to","clearProperyAfterTransition","fx","afterClearStyles","trans","fromTo","fromVal","toVal","_getProp","_fxProperties","find","effectName","state","fxProp","fxState","shouldTrans","wc","num","effectUnit","indexOf","r","match","parseFloat","isNaN","beforeAddClass","className","_beforeAddClasses","beforeRemoveClass","_beforeRemoveClasses","beforeStyles","styles","_beforeStyles","beforeClearStyles","propertyNames","_i","propertyNames_1","beforeAddRead","domReadFn","_readCallbacks","beforeAddWrite","domWriteFn","_writeCallbacks","afterAddClass","_afterAddClasses","afterRemoveClass","_afterRemoveClasses","afterStyles","_afterStyles","propertyNames_2","play","_this","_destroyed","_isAsync","_hasDuration","_clearAsync","_playInit","_playDomInspect","playAsync","Promise","resolve","onFinish","oneTimeCallback","clearExistingCallbacks","playSync","_hasTweenEffect","isPlaying","hasCompleted","_hasDur","children","children_1","_progress","_willChange","dur","_beforeAnimation","_asyncEnd","_playProgress","_playToStep","children_2","_setTrans","_setAfterStyles","_didFinish","stepValue","children_3","shouldComplete","self","_unregisterTrnsEnd","_transEl","_playEnd","_didFinishAll","_timerId","setTimeout","children_4","children_5","_hasDomReads","children_6","stop","clearTimeout","elements","effects","j","finalTransform","fromNum","toNum","tweenEffect","style","setProperty","forcedLinearEasing","durString","elements_1","transitionDuration","transitionTimingFunction","_fireBeforeReadFunc","_fireBeforeWriteFunc","_setBeforeStyles","children_7","addClasses","removeClasses","_a","elements_2","elementClassList","classList","_b","addClasses_1","c","_c","removeClasses_1","remove","_d","_e","Object","entries","_f","key","children_8","readFunctions","readFunctions_1","children_9","writeFunctions","writeFunctions_1","elements_3","beforeAddClasses","beforeAddClasses_1","beforeRemoveClasses","beforeRemoveClasses_1","keys","propName","removeProperty","afterAddClasses","afterAddClasses_1","afterRemoveClasses","afterRemoveClasses_1","_g","_h","_j","addWillChange","willChange","effects_1","propWC","join","elements_4","progressStart","_progressStart","children_10","progressStep","Math","min","max","children_11","progressEnd","currentStepValue","diff","abs","_progressEnd","isAsync","children_12","_onFinishCallbacks","_onFinishOneTimeCallbacks","finishAsyncAnimations","finishNoDurationAnimations","children_13","reverse","shouldReverse","children_14","destroy","children_15","children_16","targetEl","create","animationBuilder","baseEl"],"mappings":"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","file":"js/chunk-2d225766.40682c5a.js","sourcesContent":["var transitionEnd = function (el, callback) {\n    var unRegTrans;\n    var opts = { passive: true };\n    var unregister = function () {\n        if (unRegTrans) {\n            unRegTrans();\n        }\n    };\n    var onTransitionEnd = function (ev) {\n        if (el === ev.target) {\n            unregister();\n            callback(ev);\n        }\n    };\n    if (el) {\n        el.addEventListener('webkitTransitionEnd', onTransitionEnd, opts);\n        el.addEventListener('transitionend', onTransitionEnd, opts);\n        unRegTrans = function () {\n            el.removeEventListener('webkitTransitionEnd', onTransitionEnd, opts);\n            el.removeEventListener('transitionend', onTransitionEnd, opts);\n        };\n    }\n    return unregister;\n};\nvar CSS_VALUE_REGEX = /(^-?\\d*\\.?\\d*)(.*)/;\nvar DURATION_MIN = 32;\nvar TRANSITION_END_FALLBACK_PADDING_MS = 400;\nvar TRANSFORM_PROPS = {\n    'translateX': 1,\n    'translateY': 1,\n    'translateZ': 1,\n    'scale': 1,\n    'scaleX': 1,\n    'scaleY': 1,\n    'scaleZ': 1,\n    'rotate': 1,\n    'rotateX': 1,\n    'rotateY': 1,\n    'rotateZ': 1,\n    'skewX': 1,\n    'skewY': 1,\n    'perspective': 1\n};\nvar win = typeof window !== 'undefined' ? window : {};\nvar raf = win.requestAnimationFrame\n    ? win.requestAnimationFrame.bind(win)\n    : function (f) { return f(Date.now()); };\nvar Animator = /** @class */ (function () {\n    function Animator() {\n        this._hasDur = false;\n        this._hasTweenEffect = false;\n        this._isAsync = false;\n        this._isReverse = false;\n        this._destroyed = false;\n        this.hasChildren = false;\n        this.isPlaying = false;\n        this.hasCompleted = false;\n    }\n    Animator.prototype.addElement = function (el) {\n        if (el != null) {\n            if (el.length > 0) {\n                for (var i = 0; i < el.length; i++) {\n                    this._addEl(el[i]);\n                }\n            }\n            else {\n                this._addEl(el);\n            }\n        }\n        return this;\n    };\n    /**\n     * NO DOM\n     */\n    Animator.prototype._addEl = function (el) {\n        if (el.nodeType === 1) {\n            (this._elements = this._elements || []).push(el);\n        }\n    };\n    /**\n     * Add a child animation to this animation.\n     */\n    Animator.prototype.add = function (childAnimation) {\n        childAnimation.parent = this;\n        this.hasChildren = true;\n        (this._childAnimations = this._childAnimations || []).push(childAnimation);\n        return this;\n    };\n    /**\n     * Get the duration of this animation. If this animation does\n     * not have a duration, then it'll get the duration from its parent.\n     */\n    Animator.prototype.getDuration = function (opts) {\n        if (opts && opts.duration !== undefined) {\n            return opts.duration;\n        }\n        else if (this._duration !== undefined) {\n            return this._duration;\n        }\n        else if (this.parent) {\n            return this.parent.getDuration();\n        }\n        return 0;\n    };\n    /**\n     * Returns if the animation is a root one.\n     */\n    Animator.prototype.isRoot = function () {\n        return !this.parent;\n    };\n    /**\n     * Set the duration for this animation.\n     */\n    Animator.prototype.duration = function (milliseconds) {\n        this._duration = milliseconds;\n        return this;\n    };\n    /**\n     * Get the easing of this animation. If this animation does\n     * not have an easing, then it'll get the easing from its parent.\n     */\n    Animator.prototype.getEasing = function () {\n        if (this._isReverse && this._reversedEasingName !== undefined) {\n            return this._reversedEasingName;\n        }\n        return this._easingName !== undefined ? this._easingName : (this.parent && this.parent.getEasing()) || null;\n    };\n    /**\n     * Set the easing for this animation.\n     */\n    Animator.prototype.easing = function (name) {\n        this._easingName = name;\n        return this;\n    };\n    /**\n     * Set the easing for this reversed animation.\n     */\n    Animator.prototype.easingReverse = function (name) {\n        this._reversedEasingName = name;\n        return this;\n    };\n    /**\n     * Add the \"from\" value for a specific property.\n     */\n    Animator.prototype.from = function (prop, val) {\n        this._addProp('from', prop, val);\n        return this;\n    };\n    /**\n     * Add the \"to\" value for a specific property.\n     */\n    Animator.prototype.to = function (prop, val, clearProperyAfterTransition) {\n        if (clearProperyAfterTransition === void 0) { clearProperyAfterTransition = false; }\n        var fx = this._addProp('to', prop, val);\n        if (clearProperyAfterTransition) {\n            // if this effect is a transform then clear the transform effect\n            // otherwise just clear the actual property\n            this.afterClearStyles(fx.trans ? ['transform', '-webkit-transform'] : [prop]);\n        }\n        return this;\n    };\n    /**\n     * Shortcut to add both the \"from\" and \"to\" for the same property.\n     */\n    Animator.prototype.fromTo = function (prop, fromVal, toVal, clearProperyAfterTransition) {\n        return this.from(prop, fromVal).to(prop, toVal, clearProperyAfterTransition);\n    };\n    /**\n     * NO DOM\n     */\n    Animator.prototype._getProp = function (name) {\n        if (this._fxProperties) {\n            return this._fxProperties.find(function (prop) { return prop.effectName === name; });\n        }\n        return undefined;\n    };\n    Animator.prototype._addProp = function (state, prop, val) {\n        var fxProp = this._getProp(prop);\n        if (!fxProp) {\n            // first time we've see this EffectProperty\n            var shouldTrans = (TRANSFORM_PROPS[prop] === 1);\n            fxProp = {\n                effectName: prop,\n                trans: shouldTrans,\n                // add the will-change property for transforms or opacity\n                wc: (shouldTrans ? 'transform' : prop)\n            };\n            (this._fxProperties = this._fxProperties || []).push(fxProp);\n        }\n        // add from/to EffectState to the EffectProperty\n        var fxState = {\n            val: val,\n            num: 0,\n            effectUnit: '',\n        };\n        fxProp[state] = fxState;\n        if (typeof val === 'string' && val.indexOf(' ') < 0) {\n            var r = val.match(CSS_VALUE_REGEX);\n            if (r) {\n                var num = parseFloat(r[1]);\n                if (!isNaN(num)) {\n                    fxState.num = num;\n                }\n                fxState.effectUnit = (r[0] !== r[2] ? r[2] : '');\n            }\n        }\n        else if (typeof val === 'number') {\n            fxState.num = val;\n        }\n        return fxProp;\n    };\n    /**\n     * Add CSS class to this animation's elements\n     * before the animation begins.\n     */\n    Animator.prototype.beforeAddClass = function (className) {\n        (this._beforeAddClasses = this._beforeAddClasses || []).push(className);\n        return this;\n    };\n    /**\n     * Remove CSS class from this animation's elements\n     * before the animation begins.\n     */\n    Animator.prototype.beforeRemoveClass = function (className) {\n        (this._beforeRemoveClasses = this._beforeRemoveClasses || []).push(className);\n        return this;\n    };\n    /**\n     * Set CSS inline styles to this animation's elements\n     * before the animation begins.\n     */\n    Animator.prototype.beforeStyles = function (styles) {\n        this._beforeStyles = styles;\n        return this;\n    };\n    /**\n     * Clear CSS inline styles from this animation's elements\n     * before the animation begins.\n     */\n    Animator.prototype.beforeClearStyles = function (propertyNames) {\n        this._beforeStyles = this._beforeStyles || {};\n        for (var _i = 0, propertyNames_1 = propertyNames; _i < propertyNames_1.length; _i++) {\n            var prop = propertyNames_1[_i];\n            this._beforeStyles[prop] = '';\n        }\n        return this;\n    };\n    /**\n     * Add a function which contains DOM reads, which will run\n     * before the animation begins.\n     */\n    Animator.prototype.beforeAddRead = function (domReadFn) {\n        (this._readCallbacks = this._readCallbacks || []).push(domReadFn);\n        return this;\n    };\n    /**\n     * Add a function which contains DOM writes, which will run\n     * before the animation begins.\n     */\n    Animator.prototype.beforeAddWrite = function (domWriteFn) {\n        (this._writeCallbacks = this._writeCallbacks || []).push(domWriteFn);\n        return this;\n    };\n    /**\n     * Add CSS class to this animation's elements\n     * after the animation finishes.\n     */\n    Animator.prototype.afterAddClass = function (className) {\n        (this._afterAddClasses = this._afterAddClasses || []).push(className);\n        return this;\n    };\n    /**\n     * Remove CSS class from this animation's elements\n     * after the animation finishes.\n     */\n    Animator.prototype.afterRemoveClass = function (className) {\n        (this._afterRemoveClasses = this._afterRemoveClasses || []).push(className);\n        return this;\n    };\n    /**\n     * Set CSS inline styles to this animation's elements\n     * after the animation finishes.\n     */\n    Animator.prototype.afterStyles = function (styles) {\n        this._afterStyles = styles;\n        return this;\n    };\n    /**\n     * Clear CSS inline styles from this animation's elements\n     * after the animation finishes.\n     */\n    Animator.prototype.afterClearStyles = function (propertyNames) {\n        this._afterStyles = this._afterStyles || {};\n        for (var _i = 0, propertyNames_2 = propertyNames; _i < propertyNames_2.length; _i++) {\n            var prop = propertyNames_2[_i];\n            this._afterStyles[prop] = '';\n        }\n        return this;\n    };\n    /**\n     * Play the animation.\n     */\n    Animator.prototype.play = function (opts) {\n        var _this = this;\n        // If the animation was already invalidated (it did finish), do nothing\n        if (this._destroyed) {\n            return;\n        }\n        // this is the top level animation and is in full control\n        // of when the async play() should actually kick off\n        // if there is no duration then it'll set the TO property immediately\n        // if there is a duration, then it'll stage all animations at the\n        // FROM property and transition duration, wait a few frames, then\n        // kick off the animation by setting the TO property for each animation\n        this._isAsync = this._hasDuration(opts);\n        // ensure all past transition end events have been cleared\n        this._clearAsync();\n        // recursively kicks off the correct progress step for each child animation\n        // ******** DOM WRITE ****************\n        this._playInit(opts);\n        // doubling up RAFs since this animation was probably triggered\n        // from an input event, and just having one RAF would have this code\n        // run within the same frame as the triggering input event, and the\n        // input event probably already did way too much work for one frame\n        raf(function () {\n            raf(function () {\n                _this._playDomInspect(opts);\n            });\n        });\n    };\n    Animator.prototype.playAsync = function (opts) {\n        var _this = this;\n        return new Promise(function (resolve) {\n            _this.onFinish(resolve, { oneTimeCallback: true, clearExistingCallbacks: true });\n            _this.play(opts);\n            return _this;\n        });\n    };\n    Animator.prototype.playSync = function () {\n        // If the animation was already invalidated (it did finish), do nothing\n        if (!this._destroyed) {\n            var opts = { duration: 0 };\n            this._isAsync = false;\n            this._clearAsync();\n            this._playInit(opts);\n            this._playDomInspect(opts);\n        }\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._playInit = function (opts) {\n        // always default that an animation does not tween\n        // a tween requires that an Animation class has an element\n        // and that it has at least one FROM/TO effect\n        // and that the FROM/TO effect can tween numeric values\n        this._hasTweenEffect = false;\n        this.isPlaying = true;\n        this.hasCompleted = false;\n        this._hasDur = (this.getDuration(opts) > DURATION_MIN);\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {\n                var child = children_1[_i];\n                // ******** DOM WRITE ****************\n                child._playInit(opts);\n            }\n        }\n        if (this._hasDur) {\n            // if there is a duration then we want to start at step 0\n            // ******** DOM WRITE ****************\n            this._progress(0);\n            // add the will-change properties\n            // ******** DOM WRITE ****************\n            this._willChange(true);\n        }\n    };\n    /**\n     * DOM WRITE\n     * NO RECURSION\n     * ROOT ANIMATION\n     */\n    Animator.prototype._playDomInspect = function (opts) {\n        var _this = this;\n        // fire off all the \"before\" function that have DOM READS in them\n        // elements will be in the DOM, however visibily hidden\n        // so we can read their dimensions if need be\n        // ******** DOM READ ****************\n        // ******** DOM WRITE ****************\n        this._beforeAnimation();\n        // for the root animation only\n        // set the async TRANSITION END event\n        // and run onFinishes when the transition ends\n        var dur = this.getDuration(opts);\n        if (this._isAsync) {\n            this._asyncEnd(dur, true);\n        }\n        // ******** DOM WRITE ****************\n        this._playProgress(opts);\n        if (this._isAsync && !this._destroyed) {\n            // this animation has a duration so we need another RAF\n            // for the CSS TRANSITION properties to kick in\n            raf(function () {\n                _this._playToStep(1);\n            });\n        }\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._playProgress = function (opts) {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_2 = children; _i < children_2.length; _i++) {\n                var child = children_2[_i];\n                // ******** DOM WRITE ****************\n                child._playProgress(opts);\n            }\n        }\n        if (this._hasDur) {\n            // set the CSS TRANSITION duration/easing\n            // ******** DOM WRITE ****************\n            this._setTrans(this.getDuration(opts), false);\n        }\n        else {\n            // this animation does not have a duration, so it should not animate\n            // just go straight to the TO properties and call it done\n            // ******** DOM WRITE ****************\n            this._progress(1);\n            // since there was no animation, immediately run the after\n            // ******** DOM WRITE ****************\n            this._setAfterStyles();\n            // this animation has no duration, so it has finished\n            // other animations could still be running\n            this._didFinish(true);\n        }\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._playToStep = function (stepValue) {\n        if (!this._destroyed) {\n            var children = this._childAnimations;\n            if (children) {\n                for (var _i = 0, children_3 = children; _i < children_3.length; _i++) {\n                    var child = children_3[_i];\n                    // ******** DOM WRITE ****************\n                    child._playToStep(stepValue);\n                }\n            }\n            if (this._hasDur) {\n                // browser had some time to render everything in place\n                // and the transition duration/easing is set\n                // now set the TO properties which will trigger the transition to begin\n                // ******** DOM WRITE ****************\n                this._progress(stepValue);\n            }\n        }\n    };\n    /**\n     * DOM WRITE\n     * NO RECURSION\n     * ROOT ANIMATION\n     */\n    Animator.prototype._asyncEnd = function (dur, shouldComplete) {\n        var self = this;\n        var onTransitionEnd = function () {\n            // congrats! a successful transition completed!\n            // ensure transition end events and timeouts have been cleared\n            self._clearAsync();\n            // ******** DOM WRITE ****************\n            self._playEnd();\n            // transition finished\n            self._didFinishAll(shouldComplete, true, false);\n        };\n        var onTransitionFallback = function () {\n            // oh noz! the transition end event didn't fire in time!\n            // instead the fallback timer when first\n            // if all goes well this fallback should never fire\n            // clear the other async end events from firing\n            self._timerId = undefined;\n            self._clearAsync();\n            // set the after styles\n            // ******** DOM WRITE ****************\n            self._playEnd(shouldComplete ? 1 : 0);\n            // transition finished\n            self._didFinishAll(shouldComplete, true, false);\n        };\n        // set the TRANSITION END event on one of the transition elements\n        self._unregisterTrnsEnd = transitionEnd(self._transEl(), onTransitionEnd);\n        // set a fallback timeout if the transition end event never fires, or is too slow\n        // transition end fallback: (animation duration + XXms)\n        self._timerId = setTimeout(onTransitionFallback, (dur + TRANSITION_END_FALLBACK_PADDING_MS));\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._playEnd = function (stepValue) {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_4 = children; _i < children_4.length; _i++) {\n                var child = children_4[_i];\n                // ******** DOM WRITE ****************\n                child._playEnd(stepValue);\n            }\n        }\n        if (this._hasDur) {\n            if (stepValue !== undefined) {\n                // too late to have a smooth animation, just finish it\n                // ******** DOM WRITE ****************\n                this._setTrans(0, true);\n                // ensure the ending progress step gets rendered\n                // ******** DOM WRITE ****************\n                this._progress(stepValue);\n            }\n            // set the after styles\n            // ******** DOM WRITE ****************\n            this._setAfterStyles();\n            // remove the will-change properties\n            // ******** DOM WRITE ****************\n            this._willChange(false);\n        }\n    };\n    /**\n     * NO DOM\n     * RECURSION\n     */\n    Animator.prototype._hasDuration = function (opts) {\n        if (this.getDuration(opts) > DURATION_MIN) {\n            return true;\n        }\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_5 = children; _i < children_5.length; _i++) {\n                var child = children_5[_i];\n                if (child._hasDuration(opts)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    };\n    /**\n     * NO DOM\n     * RECURSION\n     */\n    Animator.prototype._hasDomReads = function () {\n        if (this._readCallbacks && this._readCallbacks.length > 0) {\n            return true;\n        }\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_6 = children; _i < children_6.length; _i++) {\n                var child = children_6[_i];\n                if (child._hasDomReads()) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    };\n    /**\n     * Immediately stop at the end of the animation.\n     */\n    Animator.prototype.stop = function (stepValue) {\n        if (stepValue === void 0) { stepValue = 1; }\n        // ensure all past transition end events have been cleared\n        this._clearAsync();\n        this._hasDur = true;\n        this._playEnd(stepValue);\n    };\n    /**\n     * NO DOM\n     * NO RECURSION\n     */\n    Animator.prototype._clearAsync = function () {\n        if (this._unregisterTrnsEnd) {\n            this._unregisterTrnsEnd();\n        }\n        if (this._timerId) {\n            clearTimeout(this._timerId);\n        }\n        this._timerId = this._unregisterTrnsEnd = undefined;\n    };\n    /**\n     * DOM WRITE\n     * NO RECURSION\n     */\n    Animator.prototype._progress = function (stepValue) {\n        // bread 'n butter\n        var val;\n        var elements = this._elements;\n        var effects = this._fxProperties;\n        if (!elements || elements.length === 0 || !effects || this._destroyed) {\n            return;\n        }\n        // flip the number if we're going in reverse\n        if (this._isReverse) {\n            stepValue = 1 - stepValue;\n        }\n        var i = 0;\n        var j = 0;\n        var finalTransform = '';\n        var fx;\n        for (i = 0; i < effects.length; i++) {\n            fx = effects[i];\n            if (fx.from && fx.to) {\n                var fromNum = fx.from.num;\n                var toNum = fx.to.num;\n                var tweenEffect = (fromNum !== toNum);\n                if (tweenEffect) {\n                    this._hasTweenEffect = true;\n                }\n                if (stepValue === 0) {\n                    // FROM\n                    val = fx.from.val;\n                }\n                else if (stepValue === 1) {\n                    // TO\n                    val = fx.to.val;\n                }\n                else if (tweenEffect) {\n                    // EVERYTHING IN BETWEEN\n                    var valNum = (((toNum - fromNum) * stepValue) + fromNum);\n                    var unit = fx.to.effectUnit;\n                    val = valNum + unit;\n                }\n                if (val !== null) {\n                    var prop = fx.effectName;\n                    if (fx.trans) {\n                        finalTransform += prop + '(' + val + ') ';\n                    }\n                    else {\n                        for (j = 0; j < elements.length; j++) {\n                            // ******** DOM WRITE ****************\n                            elements[j].style.setProperty(prop, val);\n                        }\n                    }\n                }\n            }\n        }\n        // place all transforms on the same property\n        if (finalTransform.length > 0) {\n            if (!this._isReverse && stepValue !== 1 || this._isReverse && stepValue !== 0) {\n                finalTransform += 'translateZ(0px)';\n            }\n            for (i = 0; i < elements.length; i++) {\n                // ******** DOM WRITE ****************\n                elements[i].style.setProperty('transform', finalTransform);\n                elements[i].style.setProperty('-webkit-transform', finalTransform);\n            }\n        }\n    };\n    /**\n     * DOM WRITE\n     * NO RECURSION\n     */\n    Animator.prototype._setTrans = function (dur, forcedLinearEasing) {\n        // Transition is not enabled if there are not effects\n        var elements = this._elements;\n        if (!elements || elements.length === 0 || !this._fxProperties) {\n            return;\n        }\n        // set the TRANSITION properties inline on the element\n        var easing = (forcedLinearEasing ? 'linear' : this.getEasing());\n        var durString = dur + 'ms';\n        for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {\n            var style = elements_1[_i].style;\n            if (dur > 0) {\n                // ******** DOM WRITE ****************\n                style.transitionDuration = durString;\n                // each animation can have a different easing\n                if (easing !== null) {\n                    // ******** DOM WRITE ****************\n                    style.transitionTimingFunction = easing;\n                }\n            }\n            else {\n                style.transitionDuration = '0';\n            }\n        }\n    };\n    /**\n     * DOM READ\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._beforeAnimation = function () {\n        // fire off all the \"before\" function that have DOM READS in them\n        // elements will be in the DOM, however visibily hidden\n        // so we can read their dimensions if need be\n        // ******** DOM READ ****************\n        this._fireBeforeReadFunc();\n        // ******** DOM READS ABOVE / DOM WRITES BELOW ****************\n        // fire off all the \"before\" function that have DOM WRITES in them\n        // ******** DOM WRITE ****************\n        this._fireBeforeWriteFunc();\n        // stage all of the before css classes and inline styles\n        // ******** DOM WRITE ****************\n        this._setBeforeStyles();\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._setBeforeStyles = function () {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_7 = children; _i < children_7.length; _i++) {\n                var child = children_7[_i];\n                child._setBeforeStyles();\n            }\n        }\n        var elements = this._elements;\n        // before the animations have started\n        // only set before styles if animation is not reversed\n        if (!elements || elements.length === 0 || this._isReverse) {\n            return;\n        }\n        var addClasses = this._beforeAddClasses;\n        var removeClasses = this._beforeRemoveClasses;\n        for (var _a = 0, elements_2 = elements; _a < elements_2.length; _a++) {\n            var el = elements_2[_a];\n            var elementClassList = el.classList;\n            // css classes to add before the animation\n            if (addClasses) {\n                for (var _b = 0, addClasses_1 = addClasses; _b < addClasses_1.length; _b++) {\n                    var c = addClasses_1[_b];\n                    // ******** DOM WRITE ****************\n                    elementClassList.add(c);\n                }\n            }\n            // css classes to remove before the animation\n            if (removeClasses) {\n                for (var _c = 0, removeClasses_1 = removeClasses; _c < removeClasses_1.length; _c++) {\n                    var c = removeClasses_1[_c];\n                    // ******** DOM WRITE ****************\n                    elementClassList.remove(c);\n                }\n            }\n            // inline styles to add before the animation\n            if (this._beforeStyles) {\n                for (var _d = 0, _e = Object.entries(this._beforeStyles); _d < _e.length; _d++) {\n                    var _f = _e[_d], key = _f[0], value = _f[1];\n                    // ******** DOM WRITE ****************\n                    el.style.setProperty(key, value);\n                }\n            }\n        }\n    };\n    /**\n     * DOM READ\n     * RECURSION\n     */\n    Animator.prototype._fireBeforeReadFunc = function () {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_8 = children; _i < children_8.length; _i++) {\n                var child = children_8[_i];\n                // ******** DOM READ ****************\n                child._fireBeforeReadFunc();\n            }\n        }\n        var readFunctions = this._readCallbacks;\n        if (readFunctions) {\n            for (var _a = 0, readFunctions_1 = readFunctions; _a < readFunctions_1.length; _a++) {\n                var callback = readFunctions_1[_a];\n                // ******** DOM READ ****************\n                callback();\n            }\n        }\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._fireBeforeWriteFunc = function () {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_9 = children; _i < children_9.length; _i++) {\n                var child = children_9[_i];\n                // ******** DOM WRITE ****************\n                child._fireBeforeWriteFunc();\n            }\n        }\n        var writeFunctions = this._writeCallbacks;\n        if (writeFunctions) {\n            for (var _a = 0, writeFunctions_1 = writeFunctions; _a < writeFunctions_1.length; _a++) {\n                var callback = writeFunctions_1[_a];\n                // ******** DOM WRITE ****************\n                callback();\n            }\n        }\n    };\n    /**\n     * DOM WRITE\n     */\n    Animator.prototype._setAfterStyles = function () {\n        var elements = this._elements;\n        if (!elements) {\n            return;\n        }\n        for (var _i = 0, elements_3 = elements; _i < elements_3.length; _i++) {\n            var el = elements_3[_i];\n            var elementClassList = el.classList;\n            // remove the transition duration/easing\n            // ******** DOM WRITE ****************\n            el.style.transitionDuration = el.style.transitionTimingFunction = '';\n            if (this._isReverse) {\n                // finished in reverse direction\n                // css classes that were added before the animation should be removed\n                var beforeAddClasses = this._beforeAddClasses;\n                if (beforeAddClasses) {\n                    for (var _a = 0, beforeAddClasses_1 = beforeAddClasses; _a < beforeAddClasses_1.length; _a++) {\n                        var c = beforeAddClasses_1[_a];\n                        elementClassList.remove(c);\n                    }\n                }\n                // css classes that were removed before the animation should be added\n                var beforeRemoveClasses = this._beforeRemoveClasses;\n                if (beforeRemoveClasses) {\n                    for (var _b = 0, beforeRemoveClasses_1 = beforeRemoveClasses; _b < beforeRemoveClasses_1.length; _b++) {\n                        var c = beforeRemoveClasses_1[_b];\n                        elementClassList.add(c);\n                    }\n                }\n                // inline styles that were added before the animation should be removed\n                var beforeStyles = this._beforeStyles;\n                if (beforeStyles) {\n                    for (var _c = 0, _d = Object.keys(beforeStyles); _c < _d.length; _c++) {\n                        var propName = _d[_c];\n                        // ******** DOM WRITE ****************\n                        el.style.removeProperty(propName);\n                    }\n                }\n            }\n            else {\n                // finished in forward direction\n                // css classes to add after the animation\n                var afterAddClasses = this._afterAddClasses;\n                if (afterAddClasses) {\n                    for (var _e = 0, afterAddClasses_1 = afterAddClasses; _e < afterAddClasses_1.length; _e++) {\n                        var c = afterAddClasses_1[_e];\n                        // ******** DOM WRITE ****************\n                        elementClassList.add(c);\n                    }\n                }\n                // css classes to remove after the animation\n                var afterRemoveClasses = this._afterRemoveClasses;\n                if (afterRemoveClasses) {\n                    for (var _f = 0, afterRemoveClasses_1 = afterRemoveClasses; _f < afterRemoveClasses_1.length; _f++) {\n                        var c = afterRemoveClasses_1[_f];\n                        // ******** DOM WRITE ****************\n                        elementClassList.remove(c);\n                    }\n                }\n                // inline styles to add after the animation\n                var afterStyles = this._afterStyles;\n                if (afterStyles) {\n                    for (var _g = 0, _h = Object.entries(afterStyles); _g < _h.length; _g++) {\n                        var _j = _h[_g], key = _j[0], value = _j[1];\n                        el.style.setProperty(key, value);\n                    }\n                }\n            }\n        }\n    };\n    /**\n     * DOM WRITE\n     * NO RECURSION\n     */\n    Animator.prototype._willChange = function (addWillChange) {\n        var wc;\n        var effects = this._fxProperties;\n        var willChange;\n        if (addWillChange && effects) {\n            wc = [];\n            for (var _i = 0, effects_1 = effects; _i < effects_1.length; _i++) {\n                var effect = effects_1[_i];\n                var propWC = effect.wc;\n                if (propWC === 'webkitTransform') {\n                    wc.push('transform', '-webkit-transform');\n                }\n                else if (propWC !== undefined) {\n                    wc.push(propWC);\n                }\n            }\n            willChange = wc.join(',');\n        }\n        else {\n            willChange = '';\n        }\n        var elements = this._elements;\n        if (elements) {\n            for (var _a = 0, elements_4 = elements; _a < elements_4.length; _a++) {\n                var el = elements_4[_a];\n                // ******** DOM WRITE ****************\n                el.style.setProperty('will-change', willChange);\n            }\n        }\n    };\n    /**\n     * Start the animation with a user controlled progress.\n     */\n    Animator.prototype.progressStart = function () {\n        // ensure all past transition end events have been cleared\n        this._clearAsync();\n        // ******** DOM READ/WRITE ****************\n        this._beforeAnimation();\n        // ******** DOM WRITE ****************\n        this._progressStart();\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._progressStart = function () {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_10 = children; _i < children_10.length; _i++) {\n                var child = children_10[_i];\n                // ******** DOM WRITE ****************\n                child._progressStart();\n            }\n        }\n        // force no duration, linear easing\n        // ******** DOM WRITE ****************\n        this._setTrans(0, true);\n        // ******** DOM WRITE ****************\n        this._willChange(true);\n    };\n    /**\n     * Set the progress step for this animation.\n     * progressStep() is not debounced, so it should not be called faster than 60FPS.\n     */\n    Animator.prototype.progressStep = function (stepValue) {\n        // only update if the last update was more than 16ms ago\n        stepValue = Math.min(1, Math.max(0, stepValue));\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_11 = children; _i < children_11.length; _i++) {\n                var child = children_11[_i];\n                // ******** DOM WRITE ****************\n                child.progressStep(stepValue);\n            }\n        }\n        // ******** DOM WRITE ****************\n        this._progress(stepValue);\n    };\n    /**\n     * End the progress animation.\n     */\n    Animator.prototype.progressEnd = function (shouldComplete, currentStepValue, dur) {\n        var _this = this;\n        if (dur === void 0) { dur = -1; }\n        if (this._isReverse) {\n            // if the animation is going in reverse then\n            // flip the step value: 0 becomes 1, 1 becomes 0\n            currentStepValue = 1 - currentStepValue;\n        }\n        var stepValue = shouldComplete ? 1 : 0;\n        var diff = Math.abs(currentStepValue - stepValue);\n        if (dur < 0) {\n            dur = this._duration || 0;\n        }\n        else if (diff < 0.05) {\n            dur = 0;\n        }\n        this._isAsync = (dur > 30);\n        this._progressEnd(shouldComplete, stepValue, dur, this._isAsync);\n        if (this._isAsync) {\n            // for the root animation only\n            // set the async TRANSITION END event\n            // and run onFinishes when the transition ends\n            // ******** DOM WRITE ****************\n            this._asyncEnd(dur, shouldComplete);\n            // this animation has a duration so we need another RAF\n            // for the CSS TRANSITION properties to kick in\n            if (!this._destroyed) {\n                raf(function () {\n                    _this._playToStep(stepValue);\n                });\n            }\n        }\n    };\n    /**\n     * DOM WRITE\n     * RECURSION\n     */\n    Animator.prototype._progressEnd = function (shouldComplete, stepValue, dur, isAsync) {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_12 = children; _i < children_12.length; _i++) {\n                var child = children_12[_i];\n                // ******** DOM WRITE ****************\n                child._progressEnd(shouldComplete, stepValue, dur, isAsync);\n            }\n        }\n        if (!isAsync) {\n            // stop immediately\n            // set all the animations to their final position\n            // ******** DOM WRITE ****************\n            this._progress(stepValue);\n            this._willChange(false);\n            this._setAfterStyles();\n            this._didFinish(shouldComplete);\n        }\n        else {\n            // animate it back to it's ending position\n            this.isPlaying = true;\n            this.hasCompleted = false;\n            this._hasDur = true;\n            // ******** DOM WRITE ****************\n            this._willChange(true);\n            this._setTrans(dur, false);\n        }\n    };\n    /**\n     * Add a callback to fire when the animation has finished.\n     */\n    Animator.prototype.onFinish = function (callback, opts) {\n        if (opts && opts.clearExistingCallbacks) {\n            this._onFinishCallbacks = this._onFinishOneTimeCallbacks = undefined;\n        }\n        if (opts && opts.oneTimeCallback) {\n            this._onFinishOneTimeCallbacks = this._onFinishOneTimeCallbacks || [];\n            this._onFinishOneTimeCallbacks.push(callback);\n        }\n        else {\n            this._onFinishCallbacks = this._onFinishCallbacks || [];\n            this._onFinishCallbacks.push(callback);\n        }\n        return this;\n    };\n    /**\n     * NO DOM\n     * RECURSION\n     */\n    Animator.prototype._didFinishAll = function (hasCompleted, finishAsyncAnimations, finishNoDurationAnimations) {\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_13 = children; _i < children_13.length; _i++) {\n                var child = children_13[_i];\n                child._didFinishAll(hasCompleted, finishAsyncAnimations, finishNoDurationAnimations);\n            }\n        }\n        if (finishAsyncAnimations && this._isAsync || finishNoDurationAnimations && !this._isAsync) {\n            this._didFinish(hasCompleted);\n        }\n    };\n    /**\n     * NO RECURSION\n     */\n    Animator.prototype._didFinish = function (hasCompleted) {\n        this.isPlaying = false;\n        this.hasCompleted = hasCompleted;\n        if (this._onFinishCallbacks) {\n            // run all finish callbacks\n            for (var _i = 0, _a = this._onFinishCallbacks; _i < _a.length; _i++) {\n                var callback = _a[_i];\n                callback(this);\n            }\n        }\n        if (this._onFinishOneTimeCallbacks) {\n            // run all \"onetime\" finish callbacks\n            for (var _b = 0, _c = this._onFinishOneTimeCallbacks; _b < _c.length; _b++) {\n                var callback = _c[_b];\n                callback(this);\n            }\n            this._onFinishOneTimeCallbacks.length = 0;\n        }\n    };\n    /**\n     * Reverse the animation.\n     */\n    Animator.prototype.reverse = function (shouldReverse) {\n        if (shouldReverse === void 0) { shouldReverse = true; }\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_14 = children; _i < children_14.length; _i++) {\n                var child = children_14[_i];\n                child.reverse(shouldReverse);\n            }\n        }\n        this._isReverse = !!shouldReverse;\n        return this;\n    };\n    /**\n     * Recursively destroy this animation and all child animations.\n     */\n    Animator.prototype.destroy = function () {\n        this._didFinish(false);\n        this._destroyed = true;\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_15 = children; _i < children_15.length; _i++) {\n                var child = children_15[_i];\n                child.destroy();\n            }\n        }\n        this._clearAsync();\n        if (this._elements) {\n            this._elements.length = 0;\n        }\n        if (this._readCallbacks) {\n            this._readCallbacks.length = 0;\n        }\n        if (this._writeCallbacks) {\n            this._writeCallbacks.length = 0;\n        }\n        this.parent = undefined;\n        if (this._childAnimations) {\n            this._childAnimations.length = 0;\n        }\n        if (this._onFinishCallbacks) {\n            this._onFinishCallbacks.length = 0;\n        }\n        if (this._onFinishOneTimeCallbacks) {\n            this._onFinishOneTimeCallbacks.length = 0;\n        }\n    };\n    /**\n     * NO DOM\n     */\n    Animator.prototype._transEl = function () {\n        // get the lowest level element that has an Animator\n        var children = this._childAnimations;\n        if (children) {\n            for (var _i = 0, children_16 = children; _i < children_16.length; _i++) {\n                var child = children_16[_i];\n                var targetEl = child._transEl();\n                if (targetEl) {\n                    return targetEl;\n                }\n            }\n        }\n        return (this._hasTweenEffect &&\n            this._hasDur &&\n            this._elements !== undefined &&\n            this._elements.length > 0 ?\n            this._elements[0] : null);\n    };\n    return Animator;\n}());\nvar create = function (animationBuilder, baseEl, opts) {\n    if (animationBuilder) {\n        return animationBuilder(Animator, baseEl, opts);\n    }\n    return Promise.resolve(new Animator());\n};\nexport { create };\n"],"sourceRoot":""}