/*! UIkit 2.25.0 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */

(function(core) {

    if (typeof define == "function" && define.amd) { // AMD

        define("uikit", function(){

            var uikit = window.UIkit || core(window, window.jQuery, window.document);

            uikit.load = function(res, req, onload, config) {

                var resources = res.split(','), load = [], i, base = (config.config && config.config.uikit && config.config.uikit.base ? config.config.uikit.base : "").replace(/\/+$/g, "");

                if (!base) {

                    throw new Error( "Please define base path to UIkit in the requirejs config." );

                }

                for (i = 0; i < resources.length; i += 1) {

                    var resource = resources[i].replace(/\./g, '/');

                    load.push(base+'/components/'+resource);

                }

                req(load, function() {

                    onload(uikit);

                });

            };

            return uikit;

        });

    }

    if (!window.jQuery) {

        throw new Error( "UIkit requires jQuery" );

    }

    if (window && window.jQuery) {

        core(window, window.jQuery, window.document);

    }

})(function(global, $, doc) {

    "use strict";

    var UI = {}, _UI = global.UIkit ? Object.create(global.UIkit) : undefined;

    UI.version = '2.25.0';

    UI.noConflict = function() {

        // restore UIkit version

        if (_UI) {

            global.UIkit = _UI;

            $.UIkit      = _UI;

            $.fn.uk      = _UI.fn;

        }

        return UI;

    };

    UI.prefix = function(str) {

        return str;

    };

    // cache jQuery

    UI.$ = $;

    UI.$doc  = UI.$(document);

    UI.$win  = UI.$(window);

    UI.$html = UI.$('html');

    UI.support = {};

    UI.support.transition = (function() {

        var transitionEnd = (function() {

            var element = doc.body || doc.documentElement,

                transEndEventNames = {

                    WebkitTransition : 'webkitTransitionEnd',

                    MozTransition    : 'transitionend',

                    OTransition      : 'oTransitionEnd otransitionend',

                    transition       : 'transitionend'

                }, name;

            for (name in transEndEventNames) {

                if (element.style[name] !== undefined) return transEndEventNames[name];

            }

        }());

        return transitionEnd && { end: transitionEnd };

    })();

    UI.support.animation = (function() {

        var animationEnd = (function() {

            var element = doc.body || doc.documentElement,

                animEndEventNames = {

                    WebkitAnimation : 'webkitAnimationEnd',

                    MozAnimation    : 'animationend',

                    OAnimation      : 'oAnimationEnd oanimationend',

                    animation       : 'animationend'

                }, name;

            for (name in animEndEventNames) {

                if (element.style[name] !== undefined) return animEndEventNames[name];

            }

        }());

        return animationEnd && { end: animationEnd };

    })();

    // requestAnimationFrame polyfill

    //https://github.com/darius/requestAnimationFrame

    (function() {

        Date.now = Date.now || function() { return new Date().getTime(); };

        var vendors = ['webkit', 'moz'];

        for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) {

            var vp = vendors[i];

            window.requestAnimationFrame = window[vp+'RequestAnimationFrame'];

            window.cancelAnimationFrame = (window[vp+'CancelAnimationFrame']

                                       || window[vp+'CancelRequestAnimationFrame']);

        }

        if (/iP(ad|hone|od).*OS 6/.test(window.navigator.userAgent) // iOS6 is buggy

            || !window.requestAnimationFrame || !window.cancelAnimationFrame) {

            var lastTime = 0;

            window.requestAnimationFrame = function(callback) {

                var now = Date.now();

                var nextTime = Math.max(lastTime + 16, now);

                return setTimeout(function() { callback(lastTime = nextTime); },

                                  nextTime - now);

            };

            window.cancelAnimationFrame = clearTimeout;

        }

    }());

    UI.support.touch = (

        ('ontouchstart' in document) ||

        (global.DocumentTouch && document instanceof global.DocumentTouch)  ||

        (global.navigator.msPointerEnabled && global.navigator.msMaxTouchPoints > 0) || //IE 10

        (global.navigator.pointerEnabled && global.navigator.maxTouchPoints > 0) || //IE >=11

        false

    );

    UI.support.mutationobserver = (global.MutationObserver || global.WebKitMutationObserver || null);

    UI.Utils = {};

    UI.Utils.isFullscreen = function() {

        return document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement || document.fullscreenElement || false;

    };

    UI.Utils.str2json = function(str, notevil) {

        try {

            if (notevil) {

                return JSON.parse(str

                    // wrap keys without quote with valid double quote

                    .replace(/([\$\w]+)\s*:/g, function(_, $1){return '"'+$1+'":';})

                    // replacing single quote wrapped ones to double quote

                    .replace(/'([^']+)'/g, function(_, $1){return '"'+$1+'"';})

                );

            } else {

                return (new Function("", "var json = " + str + "; return JSON.parse(JSON.stringify(json));"))();

            }

        } catch(e) { return false; }

    };

    UI.Utils.debounce = function(func, wait, immediate) {

        var timeout;

        return function() {

            var context = this, args = arguments;

            var later = function() {

                timeout = null;

                if (!immediate) func.apply(context, args);

            };

            var callNow = immediate && !timeout;

            clearTimeout(timeout);

            timeout = setTimeout(later, wait);

            if (callNow) func.apply(context, args);

        };

    };

    UI.Utils.removeCssRules = function(selectorRegEx) {

        var idx, idxs, stylesheet, _i, _j, _k, _len, _len1, _len2, _ref;

        if(!selectorRegEx) return;

        setTimeout(function(){

            try {

              _ref = document.styleSheets;

              for (_i = 0, _len = _ref.length; _i < _len; _i++) {

                stylesheet = _ref[_i];

                idxs = [];

                stylesheet.cssRules = stylesheet.cssRules;

                for (idx = _j = 0, _len1 = stylesheet.cssRules.length; _j < _len1; idx = ++_j) {

                  if (stylesheet.cssRules[idx].type === CSSRule.STYLE_RULE && selectorRegEx.test(stylesheet.cssRules[idx].selectorText)) {

                    idxs.unshift(idx);

                  }

                }

                for (_k = 0, _len2 = idxs.length; _k < _len2; _k++) {

                  stylesheet.deleteRule(idxs[_k]);

                }

              }

            } catch (_error) {}

        }, 0);

    };

    UI.Utils.isInView = function(element, options) {

        var $element = $(element);

        if (!$element.is(':visible')) {

            return false;

        }

        var window_left = UI.$win.scrollLeft(), window_top = UI.$win.scrollTop(), offset = $element.offset(), left = offset.left, top = offset.top;

        options = $.extend({topoffset:0, leftoffset:0}, options);

        if (top + $element.height() >= window_top && top - options.topoffset <= window_top + UI.$win.height() &&

            left + $element.width() >= window_left && left - options.leftoffset <= window_left + UI.$win.width()) {

          return true;

        } else {

          return false;

        }

    };

    UI.Utils.checkDisplay = function(context, initanimation) {

        var elements = UI.$('[data-uk-margin], [data-uk-grid-match], [data-uk-grid-margin], [data-uk-check-display]', context || document), animated;

        if (context && !elements.length) {

            elements = $(context);

        }

        elements.trigger('display.uk.check');

        // fix firefox / IE animations

        if (initanimation) {

            if (typeof(initanimation)!='string') {

                initanimation = '[class*="uk-animation-"]';

            }

            elements.find(initanimation).each(function(){

                var ele  = UI.$(this),

                    cls  = ele.attr('class'),

                    anim = cls.match(/uk\-animation\-(.+)/);

                ele.removeClass(anim[0]).width();

                ele.addClass(anim[0]);

            });

        }

        return elements;

    };

    UI.Utils.options = function(string) {

        if ($.type(string)!='string') return string;

        if (string.indexOf(':') != -1 && string.trim().substr(-1) != '}') {

            string = '{'+string+'}';

        }

        var start = (string ? string.indexOf("{") : -1), options = {};

        if (start != -1) {

            try {

                options = UI.Utils.str2json(string.substr(start));

            } catch (e) {}

        }

        return options;

    };

    UI.Utils.animate = function(element, cls) {

        var d = $.Deferred();

        element = UI.$(element);

        element.css('display', 'none').addClass(cls).one(UI.support.animation.end, function() {

            element.removeClass(cls);

            d.resolve();

        });

        element.css('display', '');

        return d.promise();

    };

    UI.Utils.uid = function(prefix) {

        return (prefix || 'id') + (new Date().getTime())+"RAND"+(Math.ceil(Math.random() * 100000));

    };

    UI.Utils.template = function(str, data) {

        var tokens = str.replace(/\n/g, '\\n').replace(/\{\{\{\s*(.+?)\s*\}\}\}/g, "{{!$1}}").split(/(\{\{\s*(.+?)\s*\}\})/g),

            i=0, toc, cmd, prop, val, fn, output = [], openblocks = 0;

        while(i < tokens.length) {

            toc = tokens[i];

            if(toc.match(/\{\{\s*(.+?)\s*\}\}/)) {

                i = i + 1;

                toc  = tokens[i];

                cmd  = toc[0];

                prop = toc.substring(toc.match(/^(\^|\#|\!|\~|\:)/) ? 1:0);

                switch(cmd) {

                    case '~':

                        output.push("for(var $i=0;$i<"+prop+".length;$i++) { var $item = "+prop+"[$i];");

                        openblocks++;

                        break;

                    case ':':

                        output.push("for(var $key in "+prop+") { var $val = "+prop+"[$key];");

                        openblocks++;

                        break;

                    case '#':

                        output.push("if("+prop+") {");

                        openblocks++;

                        break;

                    case '^':

                        output.push("if(!"+prop+") {");

                        openblocks++;

                        break;

                    case '/':

                        output.push("}");

                        openblocks--;

                        break;

                    case '!':

                        output.push("__ret.push("+prop+");");

                        break;

                    default:

                        output.push("__ret.push(escape("+prop+"));");

                        break;

                }

            } else {

                output.push("__ret.push('"+toc.replace(/\'/g, "\\'")+"');");

            }

            i = i + 1;

        }

        fn  = new Function('$data', [

            'var __ret = [];',

            'try {',

            'with($data){', (!openblocks ? output.join('') : '__ret = ["Not all blocks are closed correctly."]'), '};',

            '}catch(e){__ret = [e.message];}',

            'return __ret.join("").replace(/\\n\\n/g, "\\n");',

            "function escape(html) { return String(html).replace(/&/g, '&amp;').replace(/\"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');}"

        ].join("\n"));

        return data ? fn(data) : fn;

    };

    UI.Utils.events       = {};

    UI.Utils.events.click = UI.support.touch ? 'tap' : 'click';

    global.UIkit = UI;

    // deprecated

    UI.fn = function(command, options) {

        var args = arguments, cmd = command.match(/^([a-z\-]+)(?:\.([a-z]+))?/i), component = cmd[1], method = cmd[2];

        if (!UI[component]) {

            $.error("UIkit component [" + component + "] does not exist.");

            return this;

        }

        return this.each(function() {

            var $this = $(this), data = $this.data(component);

            if (!data) $this.data(component, (data = UI[component](this, method ? undefined : options)));

            if (method) data[method].apply(data, Array.prototype.slice.call(args, 1));

        });

    };

    $.UIkit          = UI;

    $.fn.uk          = UI.fn;

    UI.langdirection = UI.$html.attr("dir") == "rtl" ? "right" : "left";

    UI.components    = {};

    UI.component = function(name, def) {

        var fn = function(element, options) {

            var $this = this;

            this.UIkit   = UI;

            this.element = element ? UI.$(element) : null;

            this.options = $.extend(true, {}, this.defaults, options);

            this.plugins = {};

            if (this.element) {

                this.element.data(name, this);

            }

            this.init();

            (this.options.plugins.length ? this.options.plugins : Object.keys(fn.plugins)).forEach(function(plugin) {

                if (fn.plugins[plugin].init) {

                    fn.plugins[plugin].init($this);

                    $this.plugins[plugin] = true;

                }

            });

            this.trigger('init.uk.component', [name, this]);

            return this;

        };

        fn.plugins = {};

        $.extend(true, fn.prototype, {

            defaults : {plugins: []},

            boot: function(){},

            init: function(){},

            on: function(a1,a2,a3){

                return UI.$(this.element || this).on(a1,a2,a3);

            },

            one: function(a1,a2,a3){

                return UI.$(this.element || this).one(a1,a2,a3);

            },

            off: function(evt){

                return UI.$(this.element || this).off(evt);

            },

            trigger: function(evt, params) {

                return UI.$(this.element || this).trigger(evt, params);

            },

            find: function(selector) {

                return UI.$(this.element ? this.element: []).find(selector);

            },

            proxy: function(obj, methods) {

                var $this = this;

                methods.split(' ').forEach(function(method) {

                    if (!$this[method]) $this[method] = function() { return obj[method].apply(obj, arguments); };

                });

            },

            mixin: function(obj, methods) {

                var $this = this;

                methods.split(' ').forEach(function(method) {

                    if (!$this[method]) $this[method] = obj[method].bind($this);

                });

            },

            option: function() {

                if (arguments.length == 1) {

                    return this.options[arguments[0]] || undefined;

                } else if (arguments.length == 2) {

                    this.options[arguments[0]] = arguments[1];

                }

            }

        }, def);

        this.components[name] = fn;

        this[name] = function() {

            var element, options;

            if (arguments.length) {

                switch(arguments.length) {

                    case 1:

                        if (typeof arguments[0] === "string" || arguments[0].nodeType || arguments[0] instanceof jQuery) {

                            element = $(arguments[0]);

                        } else {

                            options = arguments[0];

                        }

                        break;

                    case 2:

                        element = $(arguments[0]);

                        options = arguments[1];

                        break;

                }

            }

            if (element && element.data(name)) {

                return element.data(name);

            }

            return (new UI.components[name](element, options));

        };

        if (UI.domready) {

            UI.component.boot(name);

        }

        return fn;

    };

    UI.plugin = function(component, name, def) {

        this.components[component].plugins[name] = def;

    };

    UI.component.boot = function(name) {

        if (UI.components[name].prototype && UI.components[name].prototype.boot && !UI.components[name].booted) {

            UI.components[name].prototype.boot.apply(UI, []);

            UI.components[name].booted = true;