{"version":3,"sources":["kendo.fx.js"],"names":["f","define","$","undefined","parseInteger","value","parseInt","parseCSS","element","property","css","keys","obj","propertyName","acc","push","strip3DTransforms","properties","key","transformProps","indexOf","transform2d","normalizeCSS","lowerKey","isTransformed","transformation","cssValues","toLowerCase","transforms","support","hasHW3D","length","TRANSFORM","join","animationProperty","transform","match","computed","NONE","RegExp","matrix3dRegExp","translateXRegExp","test","parseFloat","Math","atan2","capitalize","word","charAt","toUpperCase","substring","createEffect","name","definition","effectClass","Effect","extend","directions","prototype","fx","Element","direction","opt1","opt2","opt3","this","each","idx","theDirection","createToggleEffect","defaultStart","defaultEnd","IN_OUT","startValue","_startValue","endValue","_endValue","shouldHide","_shouldHide","prepare","start","end","that","out","_direction","startDataValue","data","startDataValueIsSet","isNaN","_reverse","clipInHalf","container","vertical","kendo","size","HEIGHT","WIDTH","CLIPS","replace","curProxy","EffectSet","FOUR_DIRECTIONS","TRANSFER_START_STATE","ROTATIONS","RESTORE_OVERFLOW","IGNORE_TRANSITION_EVENT_SELECTOR","Animation","Transition","window","effects","proxy","browser","transitions","scaleProperties","scale","scalex","scaley","scale3d","translateProperties","translate","translatex","translatey","translate3d","hasZoom","document","documentElement","style","zoom","cssParamsRegExp","oldEffectsRegExp","singleEffectRegExp","unitRegExp","transform2units","rotate","skew","cssPrefix","round","BLANK","PX","AUTO","HIDDEN","ORIGIN","ABORT_ID","OVERFLOW","TRANSLATE","POSITION","COMPLETE_CALLBACK","TRANSITION","BACKFACE","PERSPECTIVE","DEFAULT_PERSPECTIVE","TRANSFORM_PERSPECTIVE","left","reverse","transition","modifier","right","down","up","top","bottom","in","horizontal","fn","kendoStop","clearQueue","gotoEnd","stopQueue","stop","val","transformValue","cssText","step","elem","now","cur","prop","apply","arguments","toggleClass","classes","options","add","split","exclusive","duration","ease","setTimeout","parseEffects","input","mirror","redirectedEffect","resolved","$1","$2","effect","effectBody","timeoutID","stopTransitionCalled","stopTransition","delay","oldKeys","complete","clearTimeout","removeData","dequeue","call","speeds","merge","uniqueSort","height","event","one","taskKeys","retainPosition","completeCallback","getComputedStyles","Class","init","restore","run","jdx","target","children","childrenLength","effectName","deferred","Deferred","done","setReverse","setOptions","addRestoreProperties","is","display","reset","setup","animate","resolve","promise","i","restoreCallback","hide","teardown","effectSet","parsedEffects","elements","useTransition","queue","show","multiple","params","single","position","isFixed","originalPosition","dX","dY","currentValue","marginLeft","marginTop","msie","animatedPromise","_additionalEffects","play","additional","_duration","compositeRun","concat","_complete","noop","divisor","tmp","outerWidth","_outerWidth","outerHeight","_outerHeight","offset","previous","previousDivisor","dir","slideIn","margin","origin","axis","setLength","oldLength","realLength","overflow","appendTo","body","outerBox","box","innerBox","currentScale","fillScale","transformOrigin","x","y","_container","rotation","zIndex","_clipInHalf","clip","append","face","_face","temporary","addClass","opacity","back","temp","reverseDirection","faceClone","clone","removeAttr","backClone","staticPage","turningPage","transformStyle","find","remove","mobileOS","android","_before","_after","transitionClass","_previous","_transitionClass","Error","beforeTransition","callback","afterTransition","_both","_element","_containerClass","containerClass","e","removeClass","off","completeProxy","isAbsolute","originalOverflow","parents","filter","first","both","parent","on","animationFrame","_tickProxy","_tick","_started","tick","onEnd","onCancel","enabled","cancel","timePassed","min","Date","startDate","moveTo","movable","initial","delta","location","_easeProxy","moveAxis","easeOutExpo","t","b","c","d","pow","easeOutBack","s","result","width","inner","outer","fitScale","max","jQuery","amd","a1","a2","a3"],"mappings":"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","file":"kendo.fx.min.js","sourcesContent":["/*!\n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n                                                                                                                                                                                                       \n\n*/\n(function (f, define) {\n    define('kendo.fx', ['kendo.core'], f);\n}(function () {\n    var __meta__ = {\n        id: 'fx',\n        name: 'Effects',\n        category: 'framework',\n        description: 'Required for animation effects in all Kendo UI widgets.',\n        depends: ['core']\n    };\n    (function ($, undefined) {\n        var kendo = window.kendo, fx = kendo.effects, each = $.each, extend = $.extend, proxy = $.proxy, support = kendo.support, browser = support.browser, transforms = support.transforms, transitions = support.transitions, scaleProperties = {\n                scale: 0,\n                scalex: 0,\n                scaley: 0,\n                scale3d: 0\n            }, translateProperties = {\n                translate: 0,\n                translatex: 0,\n                translatey: 0,\n                translate3d: 0\n            }, hasZoom = typeof document.documentElement.style.zoom !== 'undefined' && !transforms, matrix3dRegExp = /matrix3?d?\\s*\\(.*,\\s*([\\d\\.\\-]+)\\w*?,\\s*([\\d\\.\\-]+)\\w*?,\\s*([\\d\\.\\-]+)\\w*?,\\s*([\\d\\.\\-]+)\\w*?/i, cssParamsRegExp = /^(-?[\\d\\.\\-]+)?[\\w\\s]*,?\\s*(-?[\\d\\.\\-]+)?[\\w\\s]*/i, translateXRegExp = /translatex?$/i, oldEffectsRegExp = /(zoom|fade|expand)(\\w+)/, singleEffectRegExp = /(zoom|fade|expand)/, unitRegExp = /[xy]$/i, transformProps = [\n                'perspective',\n                'rotate',\n                'rotatex',\n                'rotatey',\n                'rotatez',\n                'rotate3d',\n                'scale',\n                'scalex',\n                'scaley',\n                'scalez',\n                'scale3d',\n                'skew',\n                'skewx',\n                'skewy',\n                'translate',\n                'translatex',\n                'translatey',\n                'translatez',\n                'translate3d',\n                'matrix',\n                'matrix3d'\n            ], transform2d = [\n                'rotate',\n                'scale',\n                'scalex',\n                'scaley',\n                'skew',\n                'skewx',\n                'skewy',\n                'translate',\n                'translatex',\n                'translatey',\n                'matrix'\n            ], transform2units = {\n                'rotate': 'deg',\n                scale: '',\n                skew: 'px',\n                translate: 'px'\n            }, cssPrefix = transforms.css, round = Math.round, BLANK = '', PX = 'px', NONE = 'none', AUTO = 'auto', WIDTH = 'width', HEIGHT = 'height', HIDDEN = 'hidden', ORIGIN = 'origin', ABORT_ID = 'abortId', OVERFLOW = 'overflow', TRANSLATE = 'translate', POSITION = 'position', COMPLETE_CALLBACK = 'completeCallback', TRANSITION = cssPrefix + 'transition', TRANSFORM = cssPrefix + 'transform', BACKFACE = cssPrefix + 'backface-visibility', PERSPECTIVE = cssPrefix + 'perspective', DEFAULT_PERSPECTIVE = '1500px', TRANSFORM_PERSPECTIVE = 'perspective(' + DEFAULT_PERSPECTIVE + ')', directions = {\n                left: {\n                    reverse: 'right',\n                    property: 'left',\n                    transition: 'translatex',\n                    vertical: false,\n                    modifier: -1\n                },\n                right: {\n                    reverse: 'left',\n                    property: 'left',\n                    transition: 'translatex',\n                    vertical: false,\n                    modifier: 1\n                },\n                down: {\n                    reverse: 'up',\n                    property: 'top',\n                    transition: 'translatey',\n                    vertical: true,\n                    modifier: 1\n                },\n                up: {\n                    reverse: 'down',\n                    property: 'top',\n                    transition: 'translatey',\n                    vertical: true,\n                    modifier: -1\n                },\n                top: { reverse: 'bottom' },\n                bottom: { reverse: 'top' },\n                'in': {\n                    reverse: 'out',\n                    modifier: -1\n                },\n                out: {\n                    reverse: 'in',\n                    modifier: 1\n                },\n                vertical: { reverse: 'vertical' },\n                horizontal: { reverse: 'horizontal' }\n            };\n        kendo.directions = directions;\n        extend($.fn, {\n            kendoStop: function (clearQueue, gotoEnd) {\n                if (transitions) {\n                    return fx.stopQueue(this, clearQueue || false, gotoEnd || false);\n                } else {\n                    return this.stop(clearQueue, gotoEnd);\n                }\n            }\n        });\n        if (transforms && !transitions) {\n            each(transform2d, function (idx, value) {\n                $.fn[value] = function (val) {\n                    if (typeof val == 'undefined') {\n                        return animationProperty(this, value);\n                    } else {\n                        var that = $(this)[0], transformValue = value + '(' + val + transform2units[value.replace(unitRegExp, '')] + ')';\n                        if (that.style.cssText.indexOf(TRANSFORM) == -1) {\n                            $(this).css(TRANSFORM, transformValue);\n                        } else {\n                            that.style.cssText = that.style.cssText.replace(new RegExp(value + '\\\\(.*?\\\\)', 'i'), transformValue);\n                        }\n                    }\n                    return this;\n                };\n                $.fx.step[value] = function (fx) {\n                    $(fx.elem)[value](fx.now);\n                };\n            });\n            var curProxy = $.fx.prototype.cur;\n            $.fx.prototype.cur = function () {\n                if (transform2d.indexOf(this.prop) != -1) {\n                    return parseFloat($(this.elem)[this.prop]());\n                }\n                return curProxy.apply(this, arguments);\n            };\n        }\n        kendo.toggleClass = function (element, classes, options, add) {\n            if (classes) {\n                classes = classes.split(' ');\n                if (transitions) {\n                    options = extend({\n                        exclusive: 'all',\n                        duration: 400,\n                        ease: 'ease-out'\n                    }, options);\n                    element.css(TRANSITION, options.exclusive + ' ' + options.duration + 'ms ' + options.ease);\n                    setTimeout(function () {\n                        element.css(TRANSITION, '').css(HEIGHT);\n                    }, options.duration);\n                }\n                each(classes, function (idx, value) {\n                    element.toggleClass(value, add);\n                });\n            }\n            return element;\n        };\n        kendo.parseEffects = function (input, mirror) {\n            var effects = {};\n            if (typeof input === 'string') {\n                each(input.split(' '), function (idx, value) {\n                    var redirectedEffect = !singleEffectRegExp.test(value), resolved = value.replace(oldEffectsRegExp, function (match, $1, $2) {\n                            return $1 + ':' + $2.toLowerCase();\n                        }), effect = resolved.split(':'), direction = effect[1], effectBody = {};\n                    if (effect.length > 1) {\n                        effectBody.direction = mirror && redirectedEffect ? directions[direction].reverse : direction;\n                    }\n                    effects[effect[0]] = effectBody;\n                });\n            } else {\n                each(input, function (idx) {\n                    var direction = this.direction;\n                    if (direction && mirror && !singleEffectRegExp.test(idx)) {\n                        this.direction = directions[direction].reverse;\n                    }\n                    effects[idx] = this;\n                });\n            }\n            return effects;\n        };\n        function parseInteger(value) {\n            return parseInt(value, 10);\n        }\n        function parseCSS(element, property) {\n            return parseInteger(element.css(property));\n        }\n        function keys(obj) {\n            var acc = [];\n            for (var propertyName in obj) {\n                acc.push(propertyName);\n            }\n            return acc;\n        }\n        function strip3DTransforms(properties) {\n            for (var key in properties) {\n                if (transformProps.indexOf(key) != -1 && transform2d.indexOf(key) == -1) {\n                    delete properties[key];\n                }\n            }\n            return properties;\n        }\n        function normalizeCSS(element, properties) {\n            var transformation = [], cssValues = {}, lowerKey, key, value, isTransformed;\n            for (key in properties) {\n                lowerKey = key.toLowerCase();\n                isTransformed = transforms && transformProps.indexOf(lowerKey) != -1;\n                if (!support.hasHW3D && isTransformed && transform2d.indexOf(lowerKey) == -1) {\n                    delete properties[key];\n                } else {\n                    value = properties[key];\n                    if (isTransformed) {\n                        transformation.push(key + '(' + value + ')');\n                    } else {\n                        cssValues[key] = value;\n                    }\n                }\n            }\n            if (transformation.length) {\n                cssValues[TRANSFORM] = transformation.join(' ');\n            }\n            return cssValues;\n        }\n        if (transitions) {\n            extend(fx, {\n                transition: function (element, properties, options) {\n                    var css, delay = 0, oldKeys = element.data('keys') || [], timeoutID;\n                    options = extend({\n                        duration: 200,\n                        ease: 'ease-out',\n                        complete: null,\n                        exclusive: 'all'\n                    }, options);\n                    var stopTransitionCalled = false;\n                    var stopTransition = function () {\n                        if (!stopTransitionCalled) {\n                            stopTransitionCalled = true;\n                            if (timeoutID) {\n                                clearTimeout(timeoutID);\n                                timeoutID = null;\n                            }\n                            element.removeData(ABORT_ID).dequeue().css(TRANSITION, '').css(TRANSITION);\n                            options.complete.call(element);\n                        }\n                    };\n                    options.duration = $.fx ? $.fx.speeds[options.duration] || options.duration : options.duration;\n                    css = normalizeCSS(element, properties);\n                    $.merge(oldKeys, keys(css));\n                    element.data('keys', $.uniqueSort(oldKeys)).height();\n                    element.css(TRANSITION, options.exclusive + ' ' + options.duration + 'ms ' + options.ease).css(TRANSITION);\n                    element.css(css).css(TRANSFORM);\n                    if (transitions.event) {\n                        element.one(transitions.event, stopTransition);\n                        if (options.duration !== 0) {\n                            delay = 500;\n                        }\n                    }\n                    timeoutID = setTimeout(stopTransition, options.duration + delay);\n                    element.data(ABORT_ID, timeoutID);\n                    element.data(COMPLETE_CALLBACK, stopTransition);\n                },\n                stopQueue: function (element, clearQueue, gotoEnd) {\n                    var cssValues, taskKeys = element.data('keys'), retainPosition = !gotoEnd && taskKeys, completeCallback = element.data(COMPLETE_CALLBACK);\n                    if (retainPosition) {\n                        cssValues = kendo.getComputedStyles(element[0], taskKeys);\n                    }\n                    if (completeCallback) {\n                        completeCallback();\n                    }\n                    if (retainPosition) {\n                        element.css(cssValues);\n                    }\n                    return element.removeData('keys').stop(clearQueue);\n                }\n            });\n        }\n        function animationProperty(element, property) {\n            if (transforms) {\n                var transform = element.css(TRANSFORM);\n                if (transform == NONE) {\n                    return property == 'scale' ? 1 : 0;\n                }\n                var match = transform.match(new RegExp(property + '\\\\s*\\\\(([\\\\d\\\\w\\\\.]+)')), computed = 0;\n                if (match) {\n                    computed = parseInteger(match[1]);\n                } else {\n                    match = transform.match(matrix3dRegExp) || [\n                        0,\n                        0,\n                        0,\n                        0,\n                        0\n                    ];\n                    property = property.toLowerCase();\n                    if (translateXRegExp.test(property)) {\n                        computed = parseFloat(match[3] / match[2]);\n                    } else if (property == 'translatey') {\n                        computed = parseFloat(match[4] / match[2]);\n                    } else if (property == 'scale') {\n                        computed = parseFloat(match[2]);\n                    } else if (property == 'rotate') {\n                        computed = parseFloat(Math.atan2(match[2], match[1]));\n                    }\n                }\n                return computed;\n            } else {\n                return parseFloat(element.css(property));\n            }\n        }\n        var EffectSet = kendo.Class.extend({\n            init: function (element, options) {\n                var that = this;\n                that.element = element;\n                that.effects = [];\n                that.options = options;\n                that.restore = [];\n            },\n            run: function (effects) {\n                var that = this, effect, idx, jdx, length = effects.length, element = that.element, options = that.options, deferred = $.Deferred(), start = {}, end = {}, target, children, childrenLength;\n                that.effects = effects;\n                deferred.done($.proxy(that, 'complete'));\n                element.data('animating', true);\n                for (idx = 0; idx < length; idx++) {\n                    effect = effects[idx];\n                    effect.setReverse(options.reverse);\n                    effect.setOptions(options);\n                    that.addRestoreProperties(effect.restore);\n                    effect.prepare(start, end);\n                    children = effect.children();\n                    for (jdx = 0, childrenLength = children.length; jdx < childrenLength; jdx++) {\n                        children[jdx].duration(options.duration).run();\n                    }\n                }\n                for (var effectName in options.effects) {\n                    extend(end, options.effects[effectName].properties);\n                }\n                if (!element.is(':visible')) {\n                    extend(start, { display: element.data('olddisplay') || 'block' });\n                }\n                if (transforms && !options.reset) {\n                    target = element.data('targetTransform');\n                    if (target) {\n                        start = extend(target, start);\n                    }\n                }\n                start = normalizeCSS(element, start);\n                if (transforms && !transitions) {\n                    start = strip3DTransforms(start);\n                }\n                element.css(start).css(TRANSFORM);\n                for (idx = 0; idx < length; idx++) {\n                    effects[idx].setup();\n                }\n                if (options.init) {\n                    options.init();\n                }\n                element.data('targetTransform', end);\n                fx.animate(element, end, extend({}, options, { complete: deferred.resolve }));\n                return deferred.promise();\n            },\n            stop: function () {\n                $(this.element).kendoStop(true, true);\n            },\n            addRestoreProperties: function (restore) {\n                var element = this.element, value, i = 0, length = restore.length;\n                for (; i < length; i++) {\n                    value = restore[i];\n                    this.restore.push(value);\n                    if (!element.data(value)) {\n                        element.data(value, element.css(value));\n                    }\n                }\n            },\n            restoreCallback: function () {\n                var element = this.element;\n                for (var i = 0, length = this.restore.length; i < length; i++) {\n                    var value = this.restore[i];\n                    element.css(value, element.data(value));\n                }\n            },\n            complete: function () {\n                var that = this, idx = 0, element = that.element, options = that.options, effects = that.effects, length = effects.length;\n                element.removeData('animating').dequeue();\n                if (options.hide) {\n                    element.data('olddisplay', element.css('display')).hide();\n                }\n                this.restoreCallback();\n                if (hasZoom && !transforms) {\n                    setTimeout($.proxy(this, 'restoreCallback'), 0);\n                }\n                for (; idx < length; idx++) {\n                    effects[idx].teardown();\n                }\n                if (options.completeCallback) {\n                    options.completeCallback(element);\n                }\n            }\n        });\n        fx.promise = function (element, options) {\n            var effects = [], effectClass, effectSet = new EffectSet(element, options), parsedEffects = kendo.parseEffects(options.effects), effect;\n            options.effects = parsedEffects;\n            for (var effectName in parsedEffects) {\n                effectClass = fx[capitalize(effectName)];\n                if (effectClass) {\n                    effect = new effectClass(element, parsedEffects[effectName].direction);\n                    effects.push(effect);\n                }\n            }\n            if (effects[0]) {\n                effectSet.run(effects);\n            } else {\n                if (!element.is(':visible')) {\n                    element.css({ display: element.data('olddisplay') || 'block' }).css('display');\n                }\n                if (options.init) {\n                    options.init();\n                }\n                element.dequeue();\n                effectSet.complete();\n            }\n        };\n        extend(fx, {\n            animate: function (elements, properties, options) {\n                var useTransition = options.transition !== false;\n                delete options.transition;\n                if (transitions && 'transition' in fx && useTransition) {\n                    fx.transition(elements, properties, options);\n                } else {\n                    if (transforms) {\n                        elements.animate(strip3DTransforms(properties), {\n                            queue: false,\n                            show: false,\n                            hide: false,\n                            duration: options.duration,\n                            complete: options.complete\n                        });\n                    } else {\n                        elements.each(function () {\n                            var element = $(this), multiple = {};\n                            each(transformProps, function (idx, value) {\n                                var params, currentValue = properties ? properties[value] + ' ' : null;\n                                if (currentValue) {\n                                    var single = properties;\n                                    if (value in scaleProperties && properties[value] !== undefined) {\n                                        params = currentValue.match(cssParamsRegExp);\n                                        if (transforms) {\n                                            extend(single, { scale: +params[0] });\n                                        }\n                                    } else {\n                                        if (value in translateProperties && properties[value] !== undefined) {\n                                            var position = element.css(POSITION), isFixed = position == 'absolute' || position == 'fixed';\n                                            if (!element.data(TRANSLATE)) {\n                                                if (isFixed) {\n                                                    element.data(TRANSLATE, {\n                                                        top: parseCSS(element, 'top') || 0,\n                                                        left: parseCSS(element, 'left') || 0,\n                                                        bottom: parseCSS(element, 'bottom'),\n                                                        right: parseCSS(element, 'right')\n                                                    });\n                                                } else {\n                                                    element.data(TRANSLATE, {\n                                                        top: parseCSS(element, 'marginTop') || 0,\n                                                        left: parseCSS(element, 'marginLeft') || 0\n                                                    });\n                                                }\n                                            }\n                                            var originalPosition = element.data(TRANSLATE);\n                                            params = currentValue.match(cssParamsRegExp);\n                                            if (params) {\n                                                var dX = value == TRANSLATE + 'y' ? +null : +params[1], dY = value == TRANSLATE + 'y' ? +params[1] : +params[2];\n                                                if (isFixed) {\n                                                    if (!isNaN(originalPosition.right)) {\n                                                        if (!isNaN(dX)) {\n                                                            extend(single, { right: originalPosition.right - dX });\n                                                        }\n                                                    } else {\n                                                        if (!isNaN(dX)) {\n                                                            extend(single, { left: originalPosition.left + dX });\n                                                        }\n                                                    }\n                                                    if (!isNaN(originalPosition.bottom)) {\n                                                        if (!isNaN(dY)) {\n                                                            extend(single, { bottom: originalPosition.bottom - dY });\n                                                        }\n                                                    } else {\n                                                        if (!isNaN(dY)) {\n                                                            extend(single, { top: originalPosition.top + dY });\n                                                        }\n                                                    }\n                                                } else {\n                                                    if (!isNaN(dX)) {\n                                                        extend(single, { marginLeft: originalPosition.left + dX });\n                                                    }\n                                                    if (!isNaN(dY)) {\n                                                        extend(single, { marginTop: originalPosition.top + dY });\n                                                    }\n                                                }\n                                            }\n                                        }\n                                    }\n                                    if (!transforms && value != 'scale' && value in single) {\n                                        delete single[value];\n                                    }\n                                    if (single) {\n                                        extend(multiple, single);\n                                    }\n                                }\n                            });\n                            if (browser.msie) {\n                                delete multiple.scale;\n                            }\n                            element.animate(multiple, {\n                                queue: false,\n                                show: false,\n                                hide: false,\n                                duration: options.duration,\n                                complete: options.complete\n                            });\n                        });\n                    }\n                }\n            }\n        });\n        fx.animatedPromise = fx.promise;\n        var Effect = kendo.Class.extend({\n            init: function (element, direction) {\n                var that = this;\n                that.element = element;\n                that._direction = direction;\n                that.options = {};\n                that._additionalEffects = [];\n                if (!that.restore) {\n                    that.restore = [];\n                }\n            },\n            reverse: function () {\n                this._reverse = true;\n                return this.run();\n            },\n            play: function () {\n                this._reverse = false;\n                return this.run();\n            },\n            add: function (additional) {\n                this._additionalEffects.push(additional);\n                return this;\n            },\n            direction: function (value) {\n                this._direction = value;\n                return this;\n            },\n            duration: function (duration) {\n                this._duration = duration;\n                return this;\n            },\n            compositeRun: function () {\n                var that = this, effectSet = new EffectSet(that.element, {\n                        reverse: that._reverse,\n                        duration: that._duration\n                    }), effects = that._additionalEffects.concat([that]);\n                return effectSet.run(effects);\n            },\n            run: function () {\n                if (this._additionalEffects && this._additionalEffects[0]) {\n                    return this.compositeRun();\n                }\n                var that = this, element = that.element, idx = 0, restore = that.restore, length = restore.length, value, deferred = $.Deferred(), start = {}, end = {}, target, children = that.children(), childrenLength = children.length;\n                deferred.done($.proxy(that, '_complete'));\n                element.data('animating', true);\n                for (idx = 0; idx < length; idx++) {\n                    value = restore[idx];\n                    if (!element.data(value)) {\n                        element.data(value, element.css(value));\n                    }\n                }\n                for (idx = 0; idx < childrenLength; idx++) {\n                    children[idx].duration(that._duration).run();\n                }\n                that.prepare(start, end);\n                if (!element.is(':visible')) {\n                    extend(start, { display: element.data('olddisplay') || 'block' });\n                }\n                if (transforms) {\n                    target = element.data('targetTransform');\n                    if (target) {\n                        start = extend(target, start);\n                    }\n                }\n                start = normalizeCSS(element, start);\n                if (transforms && !transitions) {\n                    start = strip3DTransforms(start);\n                }\n                element.css(start).css(TRANSFORM);\n                that.setup();\n                element.data('targetTransform', end);\n                fx.animate(element, end, {\n                    duration: that._duration,\n                    complete: deferred.resolve\n                });\n                return deferred.promise();\n            },\n            stop: function () {\n                var idx = 0, children = this.children(), childrenLength = children.length;\n                for (idx = 0; idx < childrenLength; idx++) {\n                    children[idx].stop();\n                }\n                $(this.element).kendoStop(true, true);\n                return this;\n            },\n            restoreCallback: function () {\n                var element = this.element;\n                for (var i = 0, length = this.restore.length; i < length; i++) {\n                    var value = this.restore[i];\n                    element.css(value, element.data(value));\n                }\n            },\n            _complete: function () {\n                var that = this, element = that.element;\n                element.removeData('animating').dequeue();\n                that.restoreCallback();\n                if (that.shouldHide()) {\n                    element.data('olddisplay', element.css('display')).hide();\n                }\n                if (hasZoom && !transforms) {\n                    setTimeout($.proxy(that, 'restoreCallback'), 0);\n                }\n                that.teardown();\n            },\n            setOptions: function (options) {\n                extend(true, this.options, options);\n            },\n            children: function () {\n                return [];\n            },\n            shouldHide: $.noop,\n            setup: $.noop,\n            prepare: $.noop,\n            teardown: $.noop,\n            directions: [],\n            setReverse: function (reverse) {\n                this._reverse = reverse;\n                return this;\n            }\n        });\n        function capitalize(word) {\n            return word.charAt(0).toUpperCase() + word.substring(1);\n        }\n        function createEffect(name, definition) {\n            var effectClass = Effect.extend(definition), directions = effectClass.prototype.directions;\n            fx[capitalize(name)] = effectClass;\n            fx.Element.prototype[name] = function (direction, opt1, opt2, opt3) {\n                return new effectClass(this.element, direction, opt1, opt2, opt3);\n            };\n            each(directions, function (idx, theDirection) {\n                fx.Element.prototype[name + capitalize(theDirection)] = function (opt1, opt2, opt3) {\n                    return new effectClass(this.element, theDirection, opt1, opt2, opt3);\n                };\n            });\n        }\n        var FOUR_DIRECTIONS = [\n                'left',\n                'right',\n                'up',\n                'down'\n            ], IN_OUT = [\n                'in',\n                'out'\n            ];\n        createEffect('slideIn', {\n            directions: FOUR_DIRECTIONS,\n            divisor: function (value) {\n                this.options.divisor = value;\n                return this;\n            },\n            prepare: function (start, end) {\n                var that = this, tmp, element = that.element, outerWidth = kendo._outerWidth, outerHeight = kendo._outerHeight, direction = directions[that._direction], offset = -direction.modifier * (direction.vertical ? outerHeight(element) : outerWidth(element)), startValue = offset / (that.options && that.options.divisor || 1) + PX, endValue = '0px';\n                if (that._reverse) {\n                    tmp = start;\n                    start = end;\n                    end = tmp;\n                }\n                if (transforms) {\n                    start[direction.transition] = startValue;\n                    end[direction.transition] = endValue;\n                } else {\n                    start[direction.property] = startValue;\n                    end[direction.property] = endValue;\n                }\n            }\n        });\n        createEffect('tile', {\n            directions: FOUR_DIRECTIONS,\n            init: function (element, direction, previous) {\n                Effect.prototype.init.call(this, element, direction);\n                this.options = { previous: previous };\n            },\n            previousDivisor: function (value) {\n                this.options.previousDivisor = value;\n                return this;\n            },\n            children: function () {\n                var that = this, reverse = that._reverse, previous = that.options.previous, divisor = that.options.previousDivisor || 1, dir = that._direction;\n                var children = [kendo.fx(that.element).slideIn(dir).setReverse(reverse)];\n                if (previous) {\n                    children.push(kendo.fx(previous).slideIn(directions[dir].reverse).divisor(divisor).setReverse(!reverse));\n                }\n                return children;\n            }\n        });\n        function createToggleEffect(name, property, defaultStart, defaultEnd) {\n            createEffect(name, {\n                directions: IN_OUT,\n                startValue: function (value) {\n                    this._startValue = value;\n                    return this;\n                },\n                endValue: function (value) {\n                    this._endValue = value;\n                    return this;\n                },\n                shouldHide: function () {\n                    return this._shouldHide;\n                },\n                prepare: function (start, end) {\n                    var that = this, startValue, endValue, out = this._direction === 'out', startDataValue = that.element.data(property), startDataValueIsSet = !(isNaN(startDataValue) || startDataValue == defaultStart);\n                    if (startDataValueIsSet) {\n                        startValue = startDataValue;\n                    } else if (typeof this._startValue !== 'undefined') {\n                        startValue = this._startValue;\n                    } else {\n                        startValue = out ? defaultStart : defaultEnd;\n                    }\n                    if (typeof this._endValue !== 'undefined') {\n                        endValue = this._endValue;\n                    } else {\n                        endValue = out ? defaultEnd : defaultStart;\n                    }\n                    if (this._reverse) {\n                        start[property] = endValue;\n                        end[property] = startValue;\n                    } else {\n                        start[property] = startValue;\n                        end[property] = endValue;\n                    }\n                    that._shouldHide = end[property] === defaultEnd;\n                }\n            });\n        }\n        createToggleEffect('fade', 'opacity', 1, 0);\n        createToggleEffect('zoom', 'scale', 1, 0.01);\n        createEffect('slideMargin', {\n            prepare: function (start, end) {\n                var that = this, element = that.element, options = that.options, origin = element.data(ORIGIN), offset = options.offset, margin, reverse = that._reverse;\n                if (!reverse && origin === null) {\n                    element.data(ORIGIN, parseFloat(element.css('margin-' + options.axis)));\n                }\n                margin = element.data(ORIGIN) || 0;\n                end['margin-' + options.axis] = !reverse ? margin + offset : margin;\n            }\n        });\n        createEffect('slideTo', {\n            prepare: function (start, end) {\n                var that = this, element = that.element, options = that.options, offset = options.offset.split(','), reverse = that._reverse;\n                if (transforms) {\n                    end.translatex = !reverse ? offset[0] : 0;\n                    end.translatey = !reverse ? offset[1] : 0;\n                } else {\n                    end.left = !reverse ? offset[0] : 0;\n                    end.top = !reverse ? offset[1] : 0;\n                }\n                element.css('left');\n            }\n        });\n        createEffect('expand', {\n            directions: [\n                'horizontal',\n                'vertical'\n            ],\n            restore: [OVERFLOW],\n            prepare: function (start, end) {\n                var that = this, element = that.element, options = that.options, reverse = that._reverse, property = that._direction === 'vertical' ? HEIGHT : WIDTH, setLength = element[0].style[property], oldLength = element.data(property), length = parseFloat(oldLength || setLength), realLength = round(element.css(property, AUTO)[property]());\n                start.overflow = HIDDEN;\n                length = options && options.reset ? realLength || length : length || realLength;\n                end[property] = (reverse ? 0 : length) + PX;\n                start[property] = (reverse ? length : 0) + PX;\n                if (oldLength === undefined) {\n                    element.data(property, setLength);\n                }\n            },\n            shouldHide: function () {\n                return this._reverse;\n            },\n            teardown: function () {\n                var that = this, element = that.element, property = that._direction === 'vertical' ? HEIGHT : WIDTH, length = element.data(property);\n                if (length == AUTO || length === BLANK) {\n                    setTimeout(function () {\n                        element.css(property, AUTO).css(property);\n                    }, 0);\n                }\n            }\n        });\n        var TRANSFER_START_STATE = {\n            position: 'absolute',\n            marginLeft: 0,\n            marginTop: 0,\n            scale: 1\n        };\n        createEffect('transfer', {\n            init: function (element, target) {\n                this.element = element;\n                this.options = { target: target };\n                this.restore = [];\n            },\n            setup: function () {\n                this.element.appendTo(document.body);\n            },\n            prepare: function (start, end) {\n                var that = this, element = that.element, outerBox = fx.box(element), innerBox = fx.box(that.options.target), currentScale = animationProperty(element, 'scale'), scale = fx.fillScale(innerBox, outerBox), transformOrigin = fx.transformOrigin(innerBox, outerBox);\n                extend(start, TRANSFER_START_STATE);\n                end.scale = 1;\n                element.css(TRANSFORM, 'scale(1)').css(TRANSFORM);\n                element.css(TRANSFORM, 'scale(' + currentScale + ')');\n                start.top = outerBox.top;\n                start.left = outerBox.left;\n                start.transformOrigin = transformOrigin.x + PX + ' ' + transformOrigin.y + PX;\n                if (that._reverse) {\n                    start.scale = scale;\n                } else {\n                    end.scale = scale;\n                }\n            }\n        });\n        var CLIPS = {\n            top: 'rect(auto auto $size auto)',\n            bottom: 'rect($size auto auto auto)',\n            left: 'rect(auto $size auto auto)',\n            right: 'rect(auto auto auto $size)'\n        };\n        var ROTATIONS = {\n            top: {\n                start: 'rotatex(0deg)',\n                end: 'rotatex(180deg)'\n            },\n            bottom: {\n                start: 'rotatex(-180deg)',\n                end: 'rotatex(0deg)'\n            },\n            left: {\n                start: 'rotatey(0deg)',\n                end: 'rotatey(-180deg)'\n            },\n            right: {\n                start: 'rotatey(180deg)',\n                end: 'rotatey(0deg)'\n            }\n        };\n        function clipInHalf(container, direction) {\n            var vertical = kendo.directions[direction].vertical, size = container[vertical ? HEIGHT : WIDTH]() / 2 + 'px';\n            return CLIPS[direction].replace('$size', size);\n        }\n        createEffect('turningPage', {\n            directions: FOUR_DIRECTIONS,\n            init: function (element, direction, container) {\n                Effect.prototype.init.call(this, element, direction);\n                this._container = container;\n            },\n            prepare: function (start, end) {\n                var that = this, reverse = that._reverse, direction = reverse ? directions[that._direction].reverse : that._direction, rotation = ROTATIONS[direction];\n                start.zIndex = 1;\n                if (that._clipInHalf) {\n                    start.clip = clipInHalf(that._container, kendo.directions[direction].reverse);\n                }\n                start[BACKFACE] = HIDDEN;\n                end[TRANSFORM] = TRANSFORM_PERSPECTIVE + (reverse ? rotation.start : rotation.end);\n                start[TRANSFORM] = TRANSFORM_PERSPECTIVE + (reverse ? rotation.end : rotation.start);\n            },\n            setup: function () {\n                this._container.append(this.element);\n            },\n            face: function (value) {\n                this._face = value;\n                return this;\n            },\n            shouldHide: function () {\n                var that = this, reverse = that._reverse, face = that._face;\n                return reverse && !face || !reverse && face;\n            },\n            clipInHalf: function (value) {\n                this._clipInHalf = value;\n                return this;\n            },\n            temporary: function () {\n                this.element.addClass('temp-page');\n                return this;\n            }\n        });\n        createEffect('staticPage', {\n            directions: FOUR_DIRECTIONS,\n            init: function (element, direction, container) {\n                Effect.prototype.init.call(this, element, direction);\n                this._container = container;\n            },\n            restore: ['clip'],\n            prepare: function (start, end) {\n                var that = this, direction = that._reverse ? directions[that._direction].reverse : that._direction;\n                start.clip = clipInHalf(that._container, direction);\n                start.opacity = 0.999;\n                end.opacity = 1;\n            },\n            shouldHide: function () {\n                var that = this, reverse = that._reverse, face = that._face;\n                return reverse && !face || !reverse && face;\n            },\n            face: function (value) {\n                this._face = value;\n                return this;\n            }\n        });\n        createEffect('pageturn', {\n            directions: [\n                'horizontal',\n                'vertical'\n            ],\n            init: function (element, direction, face, back) {\n                Effect.prototype.init.call(this, element, direction);\n                this.options = {};\n                this.options.face = face;\n                this.options.back = back;\n            },\n            children: function () {\n                var that = this, options = that.options, direction = that._direction === 'horizontal' ? 'left' : 'top', reverseDirection = kendo.directions[direction].reverse, reverse = that._reverse, temp, faceClone = options.face.clone(true).removeAttr('id'), backClone = options.back.clone(true).removeAttr('id'), element = that.element;\n                if (reverse) {\n                    temp = direction;\n                    direction = reverseDirection;\n                    reverseDirection = temp;\n                }\n                return [\n                    kendo.fx(options.face).staticPage(direction, element).face(true).setReverse(reverse),\n                    kendo.fx(options.back).staticPage(reverseDirection, element).setReverse(reverse),\n                    kendo.fx(faceClone).turningPage(direction, element).face(true).clipInHalf(true).temporary().setReverse(reverse),\n                    kendo.fx(backClone).turningPage(reverseDirection, element).clipInHalf(true).temporary().setReverse(reverse)\n                ];\n            },\n            prepare: function (start, end) {\n                start[PERSPECTIVE] = DEFAULT_PERSPECTIVE;\n                start.transformStyle = 'preserve-3d';\n                start.opacity = 0.999;\n                end.opacity = 1;\n            },\n            teardown: function () {\n                this.element.find('.temp-page').remove();\n            }\n        });\n        createEffect('flip', {\n            directions: [\n                'horizontal',\n                'vertical'\n            ],\n            init: function (element, direction, face, back) {\n                Effect.prototype.init.call(this, element, direction);\n                this.options = {};\n                this.options.face = face;\n                this.options.back = back;\n            },\n            children: function () {\n                var that = this, options = that.options, direction = that._direction === 'horizontal' ? 'left' : 'top', reverseDirection = kendo.directions[direction].reverse, reverse = that._reverse, temp, element = that.element;\n                if (reverse) {\n                    temp = direction;\n                    direction = reverseDirection;\n                    reverseDirection = temp;\n                }\n                return [\n                    kendo.fx(options.face).turningPage(direction, element).face(true).setReverse(reverse),\n                    kendo.fx(options.back).turningPage(reverseDirection, element).setReverse(reverse)\n                ];\n            },\n            prepare: function (start) {\n                start[PERSPECTIVE] = DEFAULT_PERSPECTIVE;\n                start.transformStyle = 'preserve-3d';\n            }\n        });\n        var RESTORE_OVERFLOW = !support.mobileOS.android;\n        var IGNORE_TRANSITION_EVENT_SELECTOR = '.km-touch-scrollbar, .km-actionsheet-wrapper';\n        createEffect('replace', {\n            _before: $.noop,\n            _after: $.noop,\n            init: function (element, previous, transitionClass) {\n                Effect.prototype.init.call(this, element);\n                this._previous = $(previous);\n                this._transitionClass = transitionClass;\n            },\n            duration: function () {\n                throw new Error('The replace effect does not support duration setting; the effect duration may be customized through the transition class rule');\n            },\n            beforeTransition: function (callback) {\n                this._before = callback;\n                return this;\n            },\n            afterTransition: function (callback) {\n                this._after = callback;\n                return this;\n            },\n            _both: function () {\n                return $().add(this._element).add(this._previous);\n            },\n            _containerClass: function () {\n                var direction = this._direction, containerClass = 'k-fx k-fx-start k-fx-' + this._transitionClass;\n                if (direction) {\n                    containerClass += ' k-fx-' + direction;\n                }\n                if (this._reverse) {\n                    containerClass += ' k-fx-reverse';\n                }\n                return containerClass;\n            },\n            complete: function (e) {\n                if (!this.deferred || e && $(e.target).is(IGNORE_TRANSITION_EVENT_SELECTOR)) {\n                    return;\n                }\n                var container = this.container;\n                container.removeClass('k-fx-end').removeClass(this._containerClass()).off(transitions.event, this.completeProxy);\n                this._previous.hide().removeClass('k-fx-current');\n                this.element.removeClass('k-fx-next');\n                if (RESTORE_OVERFLOW) {\n                    container.css(OVERFLOW, '');\n                }\n                if (!this.isAbsolute) {\n                    this._both().css(POSITION, '');\n                }\n                this.deferred.resolve();\n                delete this.deferred;\n            },\n            run: function () {\n                if (this._additionalEffects && this._additionalEffects[0]) {\n                    return this.compositeRun();\n                }\n                var that = this, element = that.element, previous = that._previous, container = element.parents().filter(previous.parents()).first(), both = that._both(), deferred = $.Deferred(), originalPosition = element.css(POSITION), originalOverflow;\n                if (!container.length) {\n                    container = element.parent();\n                }\n                this.container = container;\n                this.deferred = deferred;\n                this.isAbsolute = originalPosition == 'absolute';\n                if (!this.isAbsolute) {\n                    both.css(POSITION, 'absolute');\n                }\n                if (RESTORE_OVERFLOW) {\n                    originalOverflow = container.css(OVERFLOW);\n                    container.css(OVERFLOW, 'hidden');\n                }\n                if (!transitions) {\n                    this.complete();\n                } else {\n                    element.addClass('k-fx-hidden');\n                    container.addClass(this._containerClass());\n                    this.completeProxy = $.proxy(this, 'complete');\n                    container.on(transitions.event, this.completeProxy);\n                    kendo.animationFrame(function () {\n                        element.removeClass('k-fx-hidden').addClass('k-fx-next');\n                        previous.css('display', '').addClass('k-fx-current');\n                        that._before(previous, element);\n                        kendo.animationFrame(function () {\n                            container.removeClass('k-fx-start').addClass('k-fx-end');\n                            that._after(previous, element);\n                        });\n                    });\n                }\n                return deferred.promise();\n            },\n            stop: function () {\n                this.complete();\n            }\n        });\n        var Animation = kendo.Class.extend({\n            init: function () {\n                var that = this;\n                that._tickProxy = proxy(that._tick, that);\n                that._started = false;\n            },\n            tick: $.noop,\n            done: $.noop,\n            onEnd: $.noop,\n            onCancel: $.noop,\n            start: function () {\n                if (!this.enabled()) {\n                    return;\n                }\n                if (!this.done()) {\n                    this._started = true;\n                    kendo.animationFrame(this._tickProxy);\n                } else {\n                    this.onEnd();\n                }\n            },\n            enabled: function () {\n                return true;\n            },\n            cancel: function () {\n                this._started = false;\n                this.onCancel();\n            },\n            _tick: function () {\n                var that = this;\n                if (!that._started) {\n                    return;\n                }\n                that.tick();\n                if (!that.done()) {\n                    kendo.animationFrame(that._tickProxy);\n                } else {\n                    that._started = false;\n                    that.onEnd();\n                }\n            }\n        });\n        var Transition = Animation.extend({\n            init: function (options) {\n                var that = this;\n                extend(that, options);\n                Animation.fn.init.call(that);\n            },\n            done: function () {\n                return this.timePassed() >= this.duration;\n            },\n            timePassed: function () {\n                return Math.min(this.duration, new Date() - this.startDate);\n            },\n            moveTo: function (options) {\n                var that = this, movable = that.movable;\n                that.initial = movable[that.axis];\n                that.delta = options.location - that.initial;\n                that.duration = typeof options.duration == 'number' ? options.duration : 300;\n                that.tick = that._easeProxy(options.ease);\n                that.startDate = new Date();\n                that.start();\n            },\n            _easeProxy: function (ease) {\n                var that = this;\n                return function () {\n                    that.movable.moveAxis(that.axis, ease(that.timePassed(), that.initial, that.delta, that.duration));\n                };\n            }\n        });\n        extend(Transition, {\n            easeOutExpo: function (t, b, c, d) {\n                return t == d ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;\n            },\n            easeOutBack: function (t, b, c, d, s) {\n                s = 1.70158;\n                return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;\n            }\n        });\n        fx.Animation = Animation;\n        fx.Transition = Transition;\n        fx.createEffect = createEffect;\n        fx.box = function (element) {\n            element = $(element);\n            var result = element.offset();\n            result.width = kendo._outerWidth(element);\n            result.height = kendo._outerHeight(element);\n            return result;\n        };\n        fx.transformOrigin = function (inner, outer) {\n            var x = (inner.left - outer.left) * outer.width / (outer.width - inner.width), y = (inner.top - outer.top) * outer.height / (outer.height - inner.height);\n            return {\n                x: isNaN(x) ? 0 : x,\n                y: isNaN(y) ? 0 : y\n            };\n        };\n        fx.fillScale = function (inner, outer) {\n            return Math.min(inner.width / outer.width, inner.height / outer.height);\n        };\n        fx.fitScale = function (inner, outer) {\n            return Math.max(inner.width / outer.width, inner.height / outer.height);\n        };\n    }(window.kendo.jQuery));\n    return window.kendo;\n}, typeof define == 'function' && define.amd ? define : function (a1, a2, a3) {\n    (a3 || a2)();\n}));"]}