{"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":""}