{"version":3,"sources":["webpack:///./node_modules/@ionic/core/dist/esm-es5/index-69c37885.js"],"names":["transitionEnd","el","callback","unRegTrans","opts","passive","unregister","onTransitionEnd","ev","target","addEventListener","removeEventListener","CSS_VALUE_REGEX","DURATION_MIN","TRANSITION_END_FALLBACK_PADDING_MS","TRANSFORM_PROPS","win","window","raf","requestAnimationFrame","bind","f","Date","now","Animator","this","_hasDur","_hasTweenEffect","_isAsync","_isReverse","_destroyed","hasChildren","isPlaying","hasCompleted","prototype","addElement","length","i","_addEl","nodeType","_elements","push","add","childAnimation","parent","_childAnimations","getDuration","undefined","duration","_duration","isRoot","milliseconds","getEasing","_reversedEasingName","_easingName","easing","name","easingReverse","from","prop","val","_addProp","to","clearProperyAfterTransition","fx","afterClearStyles","trans","fromTo","fromVal","toVal","_getProp","_fxProperties","find","effectName","state","fxProp","shouldTrans","wc","fxState","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","_hasDuration","_clearAsync","_playInit","_playDomInspect","playAsync","Promise","resolve","onFinish","oneTimeCallback","clearExistingCallbacks","playSync","children","children_1","child","_progress","_willChange","_beforeAnimation","dur","_asyncEnd","_playProgress","_playToStep","children_2","_setTrans","_setAfterStyles","_didFinish","stepValue","children_3","shouldComplete","self","_playEnd","_didFinishAll","onTransitionFallback","_timerId","_unregisterTrnsEnd","_transEl","setTimeout","children_4","children_5","_hasDomReads","children_6","stop","clearTimeout","elements","effects","j","finalTransform","fromNum","toNum","tweenEffect","valNum","unit","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","value","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","effect","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-77289590.ea26f470.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":""}