{"version":3,"file":"kendo.fx.min.js","names":["factory","define","amd","$","undefined$1","kendo","window","fx","effects","each","extend","support","browser","transforms","transitions","scaleProperties","scale","scalex","scaley","scale3d","translateProperties","translate","translatex","translatey","translate3d","hasZoom","document","documentElement","style","zoom","matrix3dRegExp","cssParamsRegExp","translateXRegExp","oldEffectsRegExp","singleEffectRegExp","unitRegExp","transformProps","transform2d","transform2units","rotate","skew","cssPrefix","css","round","Math","PX","AUTO","WIDTH","HEIGHT","HIDDEN","ORIGIN","ABORT_ID","OVERFLOW","TRANSLATE","POSITION","COMPLETE_CALLBACK","TRANSITION","TRANSFORM","BACKFACE","PERSPECTIVE","DEFAULT_PERSPECTIVE","TRANSFORM_PERSPECTIVE","directions","left","reverse","property","transition","vertical","modifier","right","down","up","top","bottom","in","out","horizontal","fn","kendoStop","clearQueue","gotoEnd","stopQueue","this","stop","idx","value","val","animationProperty","that","transformValue","replace","cssText","indexOf","RegExp","step","elem","now","curProxy","prototype","cur","prop","parseFloat","apply","arguments","parseInteger","parseInt","parseCSS","element","strip3DTransforms","properties","key","normalizeCSS","lowerKey","isTransformed","transformation","cssValues","toLowerCase","hasHW3D","push","length","join","transform","match","computed","test","atan2","toggleClass","classes","options","add","split","exclusive","duration","ease","setTimeout","parseEffects","input","mirror","redirectedEffect","effect","$1","$2","direction","effectBody","timeoutID","delay","oldKeys","data","complete","stopTransitionCalled","stopTransition","clearTimeout","removeData","dequeue","call","speeds","merge","obj","acc","propertyName","keys","hasOwnProperty","uniqueSort","height","unique","event","one","taskKeys","retainPosition","completeCallback","getComputedStyles","EffectSet","Class","init","restore","run","jdx","target","children","childrenLength","deferred","Deferred","start","end","done","bind","setReverse","setOptions","addRestoreProperties","prepare","effectName","is","display","reset","setup","animate","resolve","promise","i","restoreCallback","hide","teardown","effectClass","effectSet","parsedEffects","capitalize","elements","useTransition","queue","show","multiple","params","currentValue","single","position","isFixed","originalPosition","dX","dY","isNaN","marginLeft","marginTop","msie","animatedPromise","Effect","_direction","_additionalEffects","_reverse","play","additional","_duration","compositeRun","concat","_complete","shouldHide","noop","word","charAt","toUpperCase","substring","createEffect","name","definition","Element","opt1","opt2","opt3","theDirection","FOUR_DIRECTIONS","IN_OUT","createToggleEffect","defaultStart","defaultEnd","startValue","_startValue","endValue","_endValue","_shouldHide","startDataValue","divisor","tmp","outerWidth","_outerWidth","outerHeight","_outerHeight","previous","previousDivisor","dir","slideIn","margin","origin","offset","axis","setLength","oldLength","realLength","overflow","TRANSFER_START_STATE","appendTo","body","outerBox","box","innerBox","currentScale","fillScale","transformOrigin","x","y","CLIPS","ROTATIONS","clipInHalf","container","size","_container","rotation","zIndex","_clipInHalf","clip","append","face","_face","temporary","addClass","opacity","back","temp","reverseDirection","faceClone","clone","removeAttr","backClone","staticPage","turningPage","transformStyle","find","remove","RESTORE_OVERFLOW","mobileOS","android","_before","_after","transitionClass","_previous","_transitionClass","Error","beforeTransition","callback","afterTransition","_both","_element","_containerClass","containerClass","e","removeClass","off","completeProxy","isAbsolute","parents","filter","first","both","parent","on","animationFrame","Animation","_tickProxy","_tick","_started","tick","onEnd","onCancel","enabled","cancel","Transition","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"],"sources":["kendo.fx.js"],"mappings":"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","sourcesContent":["(function (factory) {\n    typeof define === 'function' && define.amd ? define(['kendo.core'], factory) :\n    factory();\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\n    (function($, undefined$1) {\n        var kendo = window.kendo,\n            fx = kendo.effects,\n            each = $.each,\n            extend = $.extend,\n            support = kendo.support,\n            browser = support.browser,\n            transforms = support.transforms,\n            transitions = support.transitions,\n            scaleProperties = { scale: 0, scalex: 0, scaley: 0, scale3d: 0 },\n            translateProperties = { translate: 0, translatex: 0, translatey: 0, translate3d: 0 },\n            hasZoom = (typeof document.documentElement.style.zoom !== \"undefined\") && !transforms,\n            matrix3dRegExp = /matrix3?d?\\s*\\(.*,\\s*([\\d\\.\\-]+)\\w*?,\\s*([\\d\\.\\-]+)\\w*?,\\s*([\\d\\.\\-]+)\\w*?,\\s*([\\d\\.\\-]+)\\w*?/i,\n            cssParamsRegExp = /^(-?[\\d\\.\\-]+)?[\\w\\s]*,?\\s*(-?[\\d\\.\\-]+)?[\\w\\s]*/i,\n            translateXRegExp = /translatex?$/i,\n            oldEffectsRegExp = /(zoom|fade|expand)(\\w+)/,\n            singleEffectRegExp = /(zoom|fade|expand)/,\n            unitRegExp = /[xy]$/i,\n            transformProps = [\"perspective\", \"rotate\", \"rotatex\", \"rotatey\", \"rotatez\", \"rotate3d\", \"scale\", \"scalex\", \"scaley\", \"scalez\", \"scale3d\", \"skew\", \"skewx\", \"skewy\", \"translate\", \"translatex\", \"translatey\", \"translatez\", \"translate3d\", \"matrix\", \"matrix3d\"],\n            transform2d = [\"rotate\", \"scale\", \"scalex\", \"scaley\", \"skew\", \"skewx\", \"skewy\", \"translate\", \"translatex\", \"translatey\", \"matrix\"],\n            transform2units = { \"rotate\": \"deg\", scale: \"\", skew: \"px\", translate: \"px\" },\n            cssPrefix = transforms.css,\n            round = Math.round,\n            BLANK = \"\",\n            PX = \"px\",\n            NONE = \"none\",\n            AUTO = \"auto\",\n            WIDTH = \"width\",\n            HEIGHT = \"height\",\n            HIDDEN = \"hidden\",\n            ORIGIN = \"origin\",\n            ABORT_ID = \"abortId\",\n            OVERFLOW = \"overflow\",\n            TRANSLATE = \"translate\",\n            POSITION = \"position\",\n            COMPLETE_CALLBACK = \"completeCallback\",\n            TRANSITION = cssPrefix + \"transition\",\n            TRANSFORM = cssPrefix + \"transform\",\n            BACKFACE = cssPrefix + \"backface-visibility\",\n            PERSPECTIVE = cssPrefix + \"perspective\",\n            DEFAULT_PERSPECTIVE = \"1500px\",\n            TRANSFORM_PERSPECTIVE = \"perspective(\" + DEFAULT_PERSPECTIVE + \")\",\n            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: {\n                    reverse: \"bottom\"\n                },\n                bottom: {\n                    reverse: \"top\"\n                },\n                \"in\": {\n                    reverse: \"out\",\n                    modifier: -1\n                },\n                out: {\n                    reverse: \"in\",\n                    modifier: 1\n                },\n\n                vertical: {\n                    reverse: \"vertical\"\n                },\n\n                horizontal: {\n                    reverse: \"horizontal\"\n                }\n            };\n\n        kendo.directions = directions;\n\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\n        /* jQuery support for all transform animations (FF 3.5/3.6, Opera 10.x, IE9 */\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],\n                            transformValue = value + \"(\" + val + transform2units[value.replace(unitRegExp, \"\")] + \")\";\n\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\n                $.fx.step[value] = function(fx) {\n                    $(fx.elem)[value](fx.now);\n                };\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\n                return curProxy.apply(this, arguments);\n            };\n        }\n\n        kendo.toggleClass = function(element, classes, options, add) {\n            if (classes) {\n                classes = classes.split(\" \");\n\n                if (transitions) {\n                    options = extend({\n                        exclusive: \"all\",\n                        duration: 400,\n                        ease: \"ease-out\"\n                    }, options);\n\n                    element.css(TRANSITION, options.exclusive + \" \" + options.duration + \"ms \" + options.ease);\n                    setTimeout(function() {\n                        element.css(TRANSITION, \"\").css(HEIGHT);\n                    }, options.duration); // TODO: this should fire a kendoAnimate session instead.\n                }\n\n                each(classes, function(idx, value) {\n                    element.toggleClass(value, add);\n                });\n            }\n\n            return element;\n        };\n\n        kendo.parseEffects = function(input, mirror) {\n            var effects = {};\n\n            if (typeof input === \"string\") {\n                each(input.split(\" \"), function(idx, value) {\n                    var redirectedEffect = !singleEffectRegExp.test(value),\n                        resolved = value.replace(oldEffectsRegExp, function(match, $1, $2) {\n                            return $1 + \":\" + $2.toLowerCase();\n                        }), // Support for old zoomIn/fadeOut style, now deprecated.\n                        effect = resolved.split(\":\"),\n                        direction = effect[1],\n                        effectBody = {};\n\n                    if (effect.length > 1) {\n                        effectBody.direction = (mirror && redirectedEffect ? directions[direction].reverse : direction);\n                    }\n\n                    effects[effect[0]] = effectBody;\n                });\n            } else {\n                each(input, function(idx) {\n                    var direction = this.direction;\n\n                    if (direction && mirror && !singleEffectRegExp.test(idx)) {\n                        this.direction = directions[direction].reverse;\n                    }\n\n                    effects[idx] = this;\n                });\n            }\n\n            return effects;\n        };\n\n        function parseInteger(value) {\n            return parseInt(value, 10);\n        }\n\n        function parseCSS(element, property) {\n            return parseInteger(element.css(property));\n        }\n\n        function keys(obj) {\n            var acc = [];\n            for (var propertyName in obj) {\n                acc.push(propertyName);\n            }\n            return acc;\n        }\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\n            return properties;\n        }\n\n        function normalizeCSS(element, properties) {\n            var transformation = [], cssValues = {}, lowerKey, key, value, isTransformed;\n\n            for (key in properties) {\n                lowerKey = key.toLowerCase();\n                isTransformed = transforms && transformProps.indexOf(lowerKey) != -1;\n\n                if (!support.hasHW3D && isTransformed && transform2d.indexOf(lowerKey) == -1) {\n                    delete properties[key];\n                } else {\n                    value = properties[key];\n\n                    if (isTransformed) {\n                        transformation.push(key + \"(\" + value + \")\");\n                    } else {\n                        cssValues[key] = value;\n                    }\n                }\n            }\n\n            if (transformation.length) {\n                cssValues[TRANSFORM] = transformation.join(\" \");\n            }\n\n            return cssValues;\n        }\n\n        if (transitions) {\n            extend(fx, {\n                transition: function(element, properties, options) {\n                    var css,\n                        delay = 0,\n                        oldKeys = element.data(\"keys\") || [],\n                        timeoutID;\n\n                    options = extend({\n                            duration: 200,\n                            ease: \"ease-out\",\n                            complete: null,\n                            exclusive: \"all\"\n                        },\n                        options\n                    );\n\n                    var stopTransitionCalled = false;\n\n                    var stopTransition = function() {\n                        if (!stopTransitionCalled) {\n                            stopTransitionCalled = true;\n\n                            if (timeoutID) {\n                                clearTimeout(timeoutID);\n                                timeoutID = null;\n                            }\n\n                            element\n                            .removeData(ABORT_ID)\n                            .dequeue()\n                            .css(TRANSITION, \"\")\n                            .css(TRANSITION);\n\n                            options.complete.call(element);\n                        }\n                    };\n\n                    options.duration = $.fx ? $.fx.speeds[options.duration] || options.duration : options.duration;\n\n                    css = normalizeCSS(element, properties);\n\n                    $.merge(oldKeys, keys(css));\n\n                    if ($.hasOwnProperty(\"uniqueSort\")) {\n                        element\n                            .data(\"keys\", $.uniqueSort(oldKeys))\n                            .height();\n                    } else {\n                        element\n                            .data(\"keys\", $.unique(oldKeys))\n                            .height();\n                    }\n\n                    element.css(TRANSITION, options.exclusive + \" \" + options.duration + \"ms \" + options.ease).css(TRANSITION);\n                    element.css(css).css(TRANSFORM);\n\n                    /**\n                     * Use transitionEnd event for browsers who support it - but duplicate it with setTimeout, as the transitionEnd event will not be triggered if no CSS properties change.\n                     * This should be cleaned up at some point (widget by widget), and refactored to widgets not relying on the complete callback if no transition occurs.\n                     *\n                     * For IE9 and below, resort to setTimeout.\n                     */\n                    if (transitions.event) {\n                        element.one(transitions.event, stopTransition);\n                        if (options.duration !== 0) {\n                            delay = 500;\n                        }\n                    }\n\n                    timeoutID = setTimeout(stopTransition, options.duration + delay);\n                    element.data(ABORT_ID, timeoutID);\n                    element.data(COMPLETE_CALLBACK, stopTransition);\n                },\n\n                stopQueue: function(element, clearQueue, gotoEnd) {\n                    var cssValues,\n                        taskKeys = element.data(\"keys\"),\n                        retainPosition = (!gotoEnd && taskKeys),\n                        completeCallback = element.data(COMPLETE_CALLBACK);\n\n                    if (retainPosition) {\n                        cssValues = kendo.getComputedStyles(element[0], taskKeys);\n                    }\n\n                    if (completeCallback) {\n                        completeCallback();\n                    }\n\n                    if (retainPosition) {\n                        element.css(cssValues);\n                    }\n\n                    return element\n                            .removeData(\"keys\")\n                            .stop(clearQueue);\n                }\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\n                var match = transform.match(new RegExp(property + \"\\\\s*\\\\(([\\\\d\\\\w\\\\.]+)\")),\n                    computed = 0;\n\n                if (match) {\n                    computed = parseInteger(match[1]);\n                } else {\n                    match = transform.match(matrix3dRegExp) || [0, 0, 0, 0, 0];\n                    property = property.toLowerCase();\n\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\n                return computed;\n            } else {\n                return parseFloat(element.css(property));\n            }\n        }\n\n        var EffectSet = kendo.Class.extend({\n            init: function(element, options) {\n                var that = this;\n\n                that.element = element;\n                that.effects = [];\n                that.options = options;\n                that.restore = [];\n            },\n\n            run: function(effects) {\n                var that = this,\n                    effect,\n                    idx, jdx,\n                    length = effects.length,\n                    element = that.element,\n                    options = that.options,\n                    deferred = $.Deferred(),\n                    start = {},\n                    end = {},\n                    target,\n                    children,\n                    childrenLength;\n\n                that.effects = effects;\n\n                deferred.done(that.complete.bind(that));\n\n                element.data(\"animating\", true);\n\n                for (idx = 0; idx < length; idx ++) {\n                    effect = effects[idx];\n\n                    effect.setReverse(options.reverse);\n                    effect.setOptions(options);\n\n                    that.addRestoreProperties(effect.restore);\n\n                    effect.prepare(start, end);\n\n                    children = effect.children();\n\n                    for (jdx = 0, childrenLength = children.length; jdx < childrenLength; jdx ++) {\n                        children[jdx].duration(options.duration).run();\n                    }\n                }\n\n                // legacy support for options.properties\n                for (var effectName in options.effects) {\n                    extend(end, options.effects[effectName].properties);\n                }\n\n                // Show the element initially\n                if (!element.is(\":visible\")) {\n                    extend(start, { display: element.data(\"olddisplay\") || \"block\" });\n                }\n\n                if (transforms && !options.reset) {\n                    target = element.data(\"targetTransform\");\n\n                    if (target) {\n                        start = extend(target, start);\n                    }\n                }\n\n                start = normalizeCSS(element, start);\n\n                if (transforms && !transitions) {\n                    start = strip3DTransforms(start);\n                }\n\n                element.css(start)\n                       .css(TRANSFORM); // Nudge\n\n                for (idx = 0; idx < length; idx ++) {\n                    effects[idx].setup();\n                }\n\n                if (options.init) {\n                    options.init();\n                }\n\n                element.data(\"targetTransform\", end);\n                fx.animate(element, end, extend({}, options, { complete: deferred.resolve }));\n\n                return deferred.promise();\n            },\n\n            stop: function() {\n                $(this.element).kendoStop(true, true);\n            },\n\n            addRestoreProperties: function(restore) {\n                var element = this.element,\n                    value,\n                    i = 0,\n                    length = restore.length;\n\n                for (; i < length; i ++) {\n                    value = restore[i];\n\n                    this.restore.push(value);\n\n                    if (!element.data(value)) {\n                        element.data(value, element.css(value));\n                    }\n                }\n            },\n\n            restoreCallback: function() {\n                var element = this.element;\n\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\n            complete: function() {\n                var that = this,\n                    idx = 0,\n                    element = that.element,\n                    options = that.options,\n                    effects = that.effects,\n                    length = effects.length;\n\n                element\n                    .removeData(\"animating\")\n                    .dequeue(); // call next animation from the queue\n\n                if (options.hide) {\n                    element.data(\"olddisplay\", element.css(\"display\")).hide();\n                }\n\n                this.restoreCallback();\n\n                if (hasZoom && !transforms) {\n                    setTimeout(this.restoreCallback.bind(this), 0); // Again jQuery callback in IE8-\n                }\n\n                for (; idx < length; idx ++) {\n                    effects[idx].teardown();\n                }\n\n                if (options.completeCallback) {\n                    options.completeCallback(element);\n                }\n            }\n        });\n\n        fx.promise = function(element, options) {\n            var effects = [],\n                effectClass,\n                effectSet = new EffectSet(element, options),\n                parsedEffects = kendo.parseEffects(options.effects),\n                effect;\n\n            options.effects = parsedEffects;\n\n            for (var effectName in parsedEffects) {\n                effectClass = fx[capitalize(effectName)];\n\n                if (effectClass) {\n                    effect = new effectClass(element, parsedEffects[effectName].direction);\n                    effects.push(effect);\n               }\n            }\n\n            if (effects[0]) {\n                effectSet.run(effects);\n            } else { // Not sure how would an fx promise reach this state - means that you call kendoAnimate with no valid effects? Why?\n                if (!element.is(\":visible\")) {\n                    element.css({ display: element.data(\"olddisplay\") || \"block\" }).css(\"display\");\n                }\n\n                if (options.init) {\n                    options.init();\n                }\n\n                element.dequeue();\n                effectSet.complete();\n            }\n        };\n\n        extend(fx, {\n            animate: function(elements, properties, options) {\n                var useTransition = options.transition !== false;\n                delete options.transition;\n\n                if (transitions && \"transition\" in fx && useTransition) {\n                    fx.transition(elements, properties, options);\n                } else {\n                    if (transforms) {\n                        elements.animate(strip3DTransforms(properties), { queue: false, show: false, hide: false, duration: options.duration, complete: options.complete }); // Stop animate from showing/hiding the element to be able to hide it later on.\n                    } else {\n                        elements.each(function() {\n                            var element = $(this),\n                                multiple = {};\n\n                            each(transformProps, function(idx, value) { // remove transforms to avoid IE and older browsers confusion\n                                var params,\n                                    currentValue = properties ? properties[value] + \" \" : null; // We need to match\n\n                                if (currentValue) {\n                                    var single = properties;\n\n                                    if (value in scaleProperties && properties[value] !== undefined$1) {\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$1) {\n                                            var position = element.css(POSITION),\n                                                isFixed = (position == \"absolute\" || position == \"fixed\");\n\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\n                                            var originalPosition = element.data(TRANSLATE);\n\n                                            params = currentValue.match(cssParamsRegExp);\n                                            if (params) {\n\n                                                var dX = value == TRANSLATE + \"y\" ? +null : +params[1],\n                                                    dY = value == TRANSLATE + \"y\" ? +params[1] : +params[2];\n\n                                                if (isFixed) {\n                                                    if (!isNaN(originalPosition.right)) {\n                                                        if (!isNaN(dX)) { extend(single, { right: originalPosition.right - dX }); }\n                                                    } else {\n                                                        if (!isNaN(dX)) { extend(single, { left: originalPosition.left + dX }); }\n                                                    }\n\n                                                    if (!isNaN(originalPosition.bottom)) {\n                                                        if (!isNaN(dY)) { extend(single, { bottom: originalPosition.bottom - dY }); }\n                                                    } else {\n                                                        if (!isNaN(dY)) { extend(single, { top: originalPosition.top + dY }); }\n                                                    }\n                                                } else {\n                                                    if (!isNaN(dX)) { extend(single, { marginLeft: originalPosition.left + dX }); }\n                                                    if (!isNaN(dY)) { 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\n                                    if (single) {\n                                        extend(multiple, single);\n                                    }\n                                }\n                            });\n\n                            if (browser.msie) {\n                                delete multiple.scale;\n                            }\n\n                            element.animate(multiple, { queue: false, show: false, hide: false, duration: options.duration, complete: options.complete }); // Stop animate from showing/hiding the element to be able to hide it later on.\n                        });\n                    }\n                }\n            }\n        });\n\n        fx.animatedPromise = fx.promise;\n\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\n                if (!that.restore) {\n                    that.restore = [];\n                }\n            },\n\n    // Public API\n            reverse: function() {\n                this._reverse = true;\n                return this.run();\n            },\n\n            play: function() {\n                this._reverse = false;\n                return this.run();\n            },\n\n            add: function(additional) {\n                this._additionalEffects.push(additional);\n                return this;\n            },\n\n            direction: function(value) {\n                this._direction = value;\n                return this;\n            },\n\n            duration: function(duration) {\n                this._duration = duration;\n                return this;\n            },\n\n            compositeRun: function() {\n                var that = this,\n                    effectSet = new EffectSet(that.element, { reverse: that._reverse, duration: that._duration }),\n                    effects = that._additionalEffects.concat([ that ]);\n\n                return effectSet.run(effects);\n            },\n\n            run: function() {\n                if (this._additionalEffects && this._additionalEffects[0]) {\n                    return this.compositeRun();\n                }\n\n                var that = this,\n                    element = that.element,\n                    idx = 0,\n                    restore = that.restore,\n                    length = restore.length,\n                    value,\n                    deferred = $.Deferred(),\n                    start = {},\n                    end = {},\n                    target,\n                    children = that.children(),\n                    childrenLength = children.length;\n\n                deferred.done(that._complete.bind(that));\n\n                element.data(\"animating\", true);\n\n                for (idx = 0; idx < length; idx ++) {\n                    value = restore[idx];\n\n                    if (!element.data(value)) {\n                        element.data(value, element.css(value));\n                    }\n                }\n\n                for (idx = 0; idx < childrenLength; idx ++) {\n                    children[idx].duration(that._duration).run();\n                }\n\n                that.prepare(start, end);\n\n                if (!element.is(\":visible\")) {\n                    extend(start, { display: element.data(\"olddisplay\") || \"block\" });\n                }\n\n                if (transforms) {\n                    target = element.data(\"targetTransform\");\n\n                    if (target) {\n                        start = extend(target, start);\n                    }\n                }\n\n                start = normalizeCSS(element, start);\n\n                if (transforms && !transitions) {\n                    start = strip3DTransforms(start);\n                }\n\n                element.css(start).css(TRANSFORM); // Trick webkit into re-rendering\n\n                that.setup();\n\n                element.data(\"targetTransform\", end);\n                fx.animate(element, end, { duration: that._duration, complete: deferred.resolve });\n\n                return deferred.promise();\n            },\n\n            stop: function() {\n                var idx = 0,\n                    children = this.children(),\n                    childrenLength = children.length;\n\n                for (idx = 0; idx < childrenLength; idx ++) {\n                    children[idx].stop();\n                }\n\n                $(this.element).kendoStop(true, true);\n                return this;\n            },\n\n            restoreCallback: function() {\n                var element = this.element;\n\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\n            _complete: function() {\n                var that = this,\n                    element = that.element;\n\n                element\n                    .removeData(\"animating\")\n                    .dequeue(); // call next animation from the queue\n\n                that.restoreCallback();\n\n                if (that.shouldHide()) {\n                    element.data(\"olddisplay\", element.css(\"display\")).hide();\n                }\n\n                if (hasZoom && !transforms) {\n                    setTimeout(that.restoreCallback.bind(that), 0); // Again jQuery callback in IE8-\n                }\n\n                that.teardown();\n            },\n\n            /////////////////////////// Support for kendo.animate;\n            setOptions: function(options) {\n                extend(true, this.options, options);\n            },\n\n            children: function() {\n                return [];\n            },\n\n            shouldHide: $.noop,\n\n            setup: $.noop,\n            prepare: $.noop,\n            teardown: $.noop,\n            directions: [],\n\n            setReverse: function(reverse) {\n                this._reverse = reverse;\n                return this;\n            }\n        });\n\n        function capitalize(word) {\n            return word.charAt(0).toUpperCase() + word.substring(1);\n        }\n\n        function createEffect(name, definition) {\n            var effectClass = Effect.extend(definition),\n                directions = effectClass.prototype.directions;\n\n            fx[capitalize(name)] = effectClass;\n\n            fx.Element.prototype[name] = function(direction, opt1, opt2, opt3) {\n                return new effectClass(this.element, direction, opt1, opt2, opt3);\n            };\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\n        var FOUR_DIRECTIONS = [\"left\", \"right\", \"up\", \"down\"],\n            IN_OUT = [\"in\", \"out\"];\n\n        createEffect(\"slideIn\", {\n            directions: FOUR_DIRECTIONS,\n\n            divisor: function(value) {\n                this.options.divisor = value;\n                return this;\n            },\n\n            prepare: function(start, end) {\n                var that = this,\n                    tmp,\n                    element = that.element,\n                    outerWidth = kendo._outerWidth,\n                    outerHeight = kendo._outerHeight,\n                    direction = directions[that._direction],\n                    offset = -direction.modifier * (direction.vertical ? outerHeight(element) : outerWidth(element)),\n                    startValue = offset / (that.options && that.options.divisor || 1) + PX,\n                    endValue = \"0px\";\n\n                if (that._reverse) {\n                    tmp = start;\n                    start = end;\n                    end = tmp;\n                }\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\n        createEffect(\"tile\", {\n            directions: FOUR_DIRECTIONS,\n\n            init: function(element, direction, previous) {\n                Effect.prototype.init.call(this, element, direction);\n                this.options = { previous: previous };\n            },\n\n            previousDivisor: function(value) {\n                this.options.previousDivisor = value;\n                return this;\n            },\n\n            children: function() {\n                var that = this,\n                    reverse = that._reverse,\n                    previous = that.options.previous,\n                    divisor = that.options.previousDivisor || 1,\n                    dir = that._direction;\n\n                var children = [ kendo.fx(that.element).slideIn(dir).setReverse(reverse) ];\n\n                if (previous) {\n                    children.push( kendo.fx(previous).slideIn(directions[dir].reverse).divisor(divisor).setReverse(!reverse) );\n                }\n\n                return children;\n            }\n        });\n\n        function createToggleEffect(name, property, defaultStart, defaultEnd) {\n            createEffect(name, {\n                directions: IN_OUT,\n\n                startValue: function(value) {\n                    this._startValue = value;\n                    return this;\n                },\n\n                endValue: function(value) {\n                    this._endValue = value;\n                    return this;\n                },\n\n                shouldHide: function() {\n                   return this._shouldHide;\n                },\n\n                prepare: function(start, end) {\n                    var that = this,\n                        startValue,\n                        endValue,\n                        out = this._direction === \"out\",\n                        startDataValue = that.element.data(property),\n                        startDataValueIsSet = !(isNaN(startDataValue) || startDataValue == defaultStart);\n\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\n                    if (typeof this._endValue !== \"undefined\") {\n                        endValue = this._endValue;\n                    } else {\n                        endValue = out ? defaultEnd : defaultStart;\n                    }\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\n                    that._shouldHide = end[property] === defaultEnd;\n                }\n            });\n        }\n\n        createToggleEffect(\"fade\", \"opacity\", 1, 0);\n        createToggleEffect(\"zoom\", \"scale\", 1, 0.01);\n\n        createEffect(\"slideMargin\", {\n            prepare: function(start, end) {\n                var that = this,\n                    element = that.element,\n                    options = that.options,\n                    origin = element.data(ORIGIN),\n                    offset = options.offset,\n                    margin,\n                    reverse = that._reverse;\n\n                if (!reverse && origin === null) {\n                    element.data(ORIGIN, parseFloat(element.css(\"margin-\" + options.axis)));\n                }\n\n                margin = (element.data(ORIGIN) || 0);\n                end[\"margin-\" + options.axis] = !reverse ? margin + offset : margin;\n            }\n        });\n\n        createEffect(\"slideTo\", {\n            prepare: function(start, end) {\n                var that = this,\n                    element = that.element,\n                    options = that.options,\n                    offset = options.offset.split(\",\"),\n                    reverse = that._reverse;\n\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\n        createEffect(\"expand\", {\n            directions: [\"horizontal\", \"vertical\"],\n\n            restore: [ OVERFLOW ],\n\n            prepare: function(start, end) {\n                var that = this,\n                    element = that.element,\n                    options = that.options,\n                    reverse = that._reverse,\n                    property = that._direction === \"vertical\" ? HEIGHT : WIDTH,\n                    setLength = element[0].style[property],\n                    oldLength = element.data(property),\n                    length = parseFloat(oldLength || setLength),\n                    realLength = round(element.css(property, AUTO)[property]());\n\n                start.overflow = HIDDEN;\n\n                length = (options && options.reset) ? realLength || length : length || realLength;\n\n                end[property] = (reverse ? 0 : length) + PX;\n                start[property] = (reverse ? length : 0) + PX;\n\n                if (oldLength === undefined$1) {\n                    element.data(property, setLength);\n                }\n            },\n\n            shouldHide: function() {\n               return this._reverse;\n            },\n\n            teardown: function() {\n                var that = this,\n                    element = that.element,\n                    property = that._direction === \"vertical\" ? HEIGHT : WIDTH,\n                    length = element.data(property);\n\n                if (length == AUTO || length === BLANK) {\n                    setTimeout(function() { element.css(property, AUTO).css(property); }, 0); // jQuery animate complete callback in IE is called before the last animation step!\n                }\n            }\n        });\n\n        var TRANSFER_START_STATE = { position: \"absolute\", marginLeft: 0, marginTop: 0, scale: 1 };\n        /**\n         * Intersection point formulas are taken from here - http://zonalandeducation.com/mmts/intersections/intersectionOfTwoLines1/intersectionOfTwoLines1.html\n         * Formula for a linear function from two points from here - http://demo.activemath.org/ActiveMath2/search/show.cmd?id=mbase://AC_UK_calculus/functions/ex_linear_equation_two_points\n         * The transform origin point is the intersection point of the two lines from the top left corners/top right corners of the element and target.\n         * The math and variables below MAY BE SIMPLIFIED (zeroes removed), but this would make the formula too cryptic.\n         */\n        createEffect(\"transfer\", {\n            init: function(element, target) {\n                this.element = element;\n                this.options = { target: target };\n                this.restore = [];\n            },\n\n            setup: function() {\n                this.element.appendTo(document.body);\n            },\n\n            prepare: function(start, end) {\n                var that = this,\n                    element = that.element,\n                    outerBox = fx.box(element),\n                    innerBox = fx.box(that.options.target),\n                    currentScale = animationProperty(element, \"scale\"),\n                    scale = fx.fillScale(innerBox, outerBox),\n                    transformOrigin = fx.transformOrigin(innerBox, outerBox);\n\n                extend(start, TRANSFER_START_STATE);\n                end.scale = 1;\n\n                element.css(TRANSFORM, \"scale(1)\").css(TRANSFORM);\n                element.css(TRANSFORM, \"scale(\" + currentScale + \")\");\n\n                start.top = outerBox.top;\n                start.left = outerBox.left;\n                start.transformOrigin = transformOrigin.x + PX + \" \" + transformOrigin.y + PX;\n\n                if (that._reverse) {\n                    start.scale = scale;\n                } else {\n                    end.scale = scale;\n                }\n            }\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\n        var ROTATIONS = {\n            top: { start: \"rotatex(0deg)\", end: \"rotatex(180deg)\" },\n            bottom: { start: \"rotatex(-180deg)\", end: \"rotatex(0deg)\" },\n            left: { start: \"rotatey(0deg)\", end: \"rotatey(-180deg)\" },\n            right: { start: \"rotatey(180deg)\", end: \"rotatey(0deg)\" }\n        };\n\n        function clipInHalf(container, direction) {\n            var vertical = kendo.directions[direction].vertical,\n                size = (container[vertical ? HEIGHT : WIDTH]() / 2) + \"px\";\n\n            return CLIPS[direction].replace(\"$size\", size);\n        }\n\n        createEffect(\"turningPage\", {\n            directions: FOUR_DIRECTIONS,\n\n            init: function(element, direction, container) {\n                Effect.prototype.init.call(this, element, direction);\n                this._container = container;\n            },\n\n            prepare: function(start, end) {\n                var that = this,\n                    reverse = that._reverse,\n                    direction = reverse ? directions[that._direction].reverse : that._direction,\n                    rotation = ROTATIONS[direction];\n\n                start.zIndex = 1;\n\n                if (that._clipInHalf) {\n                   start.clip = clipInHalf(that._container, kendo.directions[direction].reverse);\n                }\n\n                start[BACKFACE] = HIDDEN;\n\n                end[TRANSFORM] = TRANSFORM_PERSPECTIVE + (reverse ? rotation.start : rotation.end);\n                start[TRANSFORM] = TRANSFORM_PERSPECTIVE + (reverse ? rotation.end : rotation.start);\n            },\n\n            setup: function() {\n                this._container.append(this.element);\n            },\n\n            face: function(value) {\n                this._face = value;\n                return this;\n            },\n\n            shouldHide: function() {\n                var that = this,\n                    reverse = that._reverse,\n                    face = that._face;\n\n                return (reverse && !face) || (!reverse && face);\n            },\n\n            clipInHalf: function(value) {\n                this._clipInHalf = value;\n                return this;\n            },\n\n            temporary: function() {\n                this.element.addClass('temp-page');\n                return this;\n            }\n        });\n\n        createEffect(\"staticPage\", {\n            directions: FOUR_DIRECTIONS,\n\n            init: function(element, direction, container) {\n                Effect.prototype.init.call(this, element, direction);\n                this._container = container;\n            },\n\n            restore: [\"clip\"],\n\n            prepare: function(start, end) {\n                var that = this,\n                    direction = that._reverse ? directions[that._direction].reverse : that._direction;\n\n                start.clip = clipInHalf(that._container, direction);\n                start.opacity = 0.999;\n                end.opacity = 1;\n            },\n\n            shouldHide: function() {\n                var that = this,\n                    reverse = that._reverse,\n                    face = that._face;\n\n                return (reverse && !face) || (!reverse && face);\n            },\n\n            face: function(value) {\n                this._face = value;\n                return this;\n            }\n        });\n\n        createEffect(\"pageturn\", {\n            directions: [\"horizontal\", \"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\n            children: function() {\n                var that = this,\n                    options = that.options,\n                    direction = that._direction === \"horizontal\" ? \"left\" : \"top\",\n                    reverseDirection = kendo.directions[direction].reverse,\n                    reverse = that._reverse,\n                    temp,\n                    faceClone = options.face.clone(true).removeAttr(\"id\"),\n                    backClone = options.back.clone(true).removeAttr(\"id\"),\n                    element = that.element;\n\n                if (reverse) {\n                    temp = direction;\n                    direction = reverseDirection;\n                    reverseDirection = temp;\n                }\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\n            prepare: function(start, end) {\n                start[PERSPECTIVE] = DEFAULT_PERSPECTIVE;\n                start.transformStyle = \"preserve-3d\";\n                // hack to trigger transition end.\n                start.opacity = 0.999;\n                end.opacity = 1;\n            },\n\n            teardown: function() {\n                this.element.find(\".temp-page\").remove();\n            }\n        });\n\n        createEffect(\"flip\", {\n            directions: [\"horizontal\", \"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\n            children: function() {\n                var that = this,\n                    options = that.options,\n                    direction = that._direction === \"horizontal\" ? \"left\" : \"top\",\n                    reverseDirection = kendo.directions[direction].reverse,\n                    reverse = that._reverse,\n                    temp,\n                    element = that.element;\n\n                if (reverse) {\n                    temp = direction;\n                    direction = reverseDirection;\n                    reverseDirection = temp;\n                }\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\n            prepare: function(start) {\n                start[PERSPECTIVE] = DEFAULT_PERSPECTIVE;\n                start.transformStyle = \"preserve-3d\";\n            }\n        });\n\n        var RESTORE_OVERFLOW = !support.mobileOS.android;\n        var IGNORE_TRANSITION_EVENT_SELECTOR = \".km-touch-scrollbar, .km-actionsheet-wrapper\";\n\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\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\n            beforeTransition: function(callback) {\n                this._before = callback;\n                return this;\n            },\n\n            afterTransition: function(callback) {\n                this._after = callback;\n                return this;\n            },\n\n            _both: function() {\n                return $().add(this._element).add(this._previous);\n            },\n\n            _containerClass: function() {\n                var direction = this._direction,\n                    containerClass = \"k-fx k-fx-start k-fx-\" + this._transitionClass;\n\n                if (direction) {\n                    containerClass += \" k-fx-\" + direction;\n                }\n\n                if (this._reverse) {\n                    containerClass += \" k-fx-reverse\";\n                }\n\n                return containerClass;\n            },\n\n            complete: function(e) {\n                if (!this.deferred || (e && $(e.target).is(IGNORE_TRANSITION_EVENT_SELECTOR))) {\n                    return;\n                }\n\n                var container = this.container;\n\n                container\n                    .removeClass(\"k-fx-end\")\n                    .removeClass(this._containerClass())\n                    .off(transitions.event, this.completeProxy);\n\n                this._previous.hide().removeClass(\"k-fx-current\");\n                this.element.removeClass(\"k-fx-next\");\n\n                if (RESTORE_OVERFLOW) {\n                    container.css(OVERFLOW, \"\");\n                }\n\n                if (!this.isAbsolute) {\n                    this._both().css(POSITION, \"\");\n                }\n\n                this.deferred.resolve();\n                delete this.deferred;\n            },\n\n            run: function() {\n                if (this._additionalEffects && this._additionalEffects[0]) {\n                    return this.compositeRun();\n                }\n\n                var that = this,\n                    element = that.element,\n                    previous = that._previous,\n                    container = element.parents().filter(previous.parents()).first(),\n                    both = that._both(),\n                    deferred = $.Deferred(),\n                    originalPosition = element.css(POSITION),\n                    originalOverflow;\n\n                // edge case for grid/scheduler, where the previous is already destroyed.\n                if (!container.length) {\n                    container = element.parent();\n                }\n\n                this.container = container;\n                this.deferred = deferred;\n                this.isAbsolute = originalPosition == \"absolute\";\n\n                if (!this.isAbsolute) {\n                    both.css(POSITION, \"absolute\");\n                }\n\n                if (RESTORE_OVERFLOW) {\n                    originalOverflow = container.css(OVERFLOW);\n                    container.css(OVERFLOW, \"hidden\");\n                }\n\n                if (!transitions) {\n                    this.complete();\n                } else {\n                    element.addClass(\"k-fx-hidden\");\n\n                    container.addClass(this._containerClass());\n\n                    this.completeProxy = this.complete.bind(this);\n                    container.on(transitions.event, this.completeProxy);\n\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\n                return deferred.promise();\n            },\n\n            stop: function() {\n                this.complete();\n            }\n        });\n\n        var Animation = kendo.Class.extend({\n            init: function() {\n                var that = this;\n                that._tickProxy = that._tick.bind(that);\n                that._started = false;\n            },\n\n            tick: $.noop,\n            done: $.noop,\n            onEnd: $.noop,\n            onCancel: $.noop,\n\n            start: function() {\n                if (!this.enabled()) {\n                    return;\n                }\n\n                if (!this.done()) {\n                    this._started = true;\n                    kendo.animationFrame(this._tickProxy);\n                } else {\n                    this.onEnd();\n                }\n            },\n\n            enabled: function() {\n                return true;\n            },\n\n            cancel: function() {\n                this._started = false;\n                this.onCancel();\n            },\n\n            _tick: function() {\n                var that = this;\n                if (!that._started) { return; }\n\n                that.tick();\n\n                if (!that.done()) {\n                    kendo.animationFrame(that._tickProxy);\n                } else {\n                    that._started = false;\n                    that.onEnd();\n                }\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\n            done: function() {\n                return this.timePassed() >= this.duration;\n            },\n\n            timePassed: function() {\n                return Math.min(this.duration, (new Date()) - this.startDate);\n            },\n\n            moveTo: function(options) {\n                var that = this,\n                    movable = that.movable;\n\n                that.initial = movable[that.axis];\n                that.delta = options.location - that.initial;\n\n                that.duration = typeof options.duration == \"number\" ? options.duration : 300;\n\n                that.tick = that._easeProxy(options.ease);\n\n                that.startDate = new Date();\n                that.start();\n            },\n\n            _easeProxy: function(ease) {\n                var that = this;\n\n                return function() {\n                    that.movable.moveAxis(that.axis, ease(that.timePassed(), that.initial, that.delta, that.duration));\n                };\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\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\n        fx.Animation = Animation;\n        fx.Transition = Transition;\n        fx.createEffect = createEffect;\n\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\n        fx.transformOrigin = function(inner, outer) {\n            var x = (inner.left - outer.left) * outer.width / (outer.width - inner.width),\n                y = (inner.top - outer.top) * outer.height / (outer.height - inner.height);\n\n            return {\n                x: isNaN(x) ? 0 : x,\n                y: isNaN(y) ? 0 : y\n            };\n        };\n\n        fx.fillScale = function(inner, outer) {\n            return Math.min(inner.width / outer.width, inner.height / outer.height);\n        };\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\n}));\n"]}