/*! UIkit 2.27.2 | www.getuikit.com | © 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.27.2';

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.throttle = function (func, limit) {
    var wait = false;
    return function () {
        if (!wait) {
            func.call();
            wait = true;
            setTimeout(function () {
                wait = false;
            }, limit);
        }
    }
};

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.focus = function(element, extra) {

    element = $(element);

    if (!element.length) {
        return element;
    }

    var autofocus = element.find('[autofocus]:first'), tabidx;

    if (autofocus.length) {
        return autofocus.focus();
    }

    autofocus = element.find(':input'+(extra && (','+extra) || '')).first();

    if (autofocus.length) {
        return autofocus.focus();
    }

    if (!element.attr('tabindex')) {
        tabidx = 1000;
        element.attr('tabindex', tabidx);
    }

    element[0].focus();

    if (tabidx) {
        element.attr('tabindex', '');
    }

    return element;
}

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;
    }
};

UI.component.bootComponents = function() {

    for (var component in UI.components) {
        UI.component.boot(component);
    }
};

// DOM mutation save ready helper function

UI.domObservers = [];
UI.domready     = false;

UI.ready = function(fn) {

    UI.domObservers.push(fn);

    if (UI.domready) {
        fn(document);
    }
};

UI.on = function(a1,a2,a3){

    if (a1 && a1.indexOf('ready.uk.dom') > -1 && UI.domready) {
        a2.apply(UI.$doc);
    }

    return UI.$doc.on(a1,a2,a3);
};

UI.one = function(a1,a2,a3){

    if (a1 && a1.indexOf('ready.uk.dom') > -1 && UI.domready) {
        a2.apply(UI.$doc);
        return UI.$doc;
    }

    return UI.$doc.one(a1,a2,a3);
};

UI.trigger = function(evt, params) {
    return UI.$doc.trigger(evt, params);
};

UI.domObserve = function(selector, fn) {

    if(!UI.support.mutationobserver) return;

    fn = fn || function() {};

    UI.$(selector).each(function() {

        var element  = this,
            $element = UI.$(element);

        if ($element.data('observer')) {
            return;
        }

        try {

            var observer = new UI.support.mutationobserver(UI.Utils.debounce(function(mutations) {
                fn.apply(element, [$element]);
                $element.trigger('changed.uk.dom');
            }, 50), {childList: true, subtree: true});

            // pass in the target node, as well as the observer options
            observer.observe(element, { childList: true, subtree: true });

            $element.data('observer', observer);

        } catch(e) {}
    });
};

UI.init = function(root) {

    root = root || document;

    UI.domObservers.forEach(function(fn){
        fn(root);
    });
};

UI.on('domready.uk.dom', function(){

    UI.init();

    if (UI.domready) UI.Utils.checkDisplay();
});

document.addEventListener('DOMContentLoaded', function(){

    var domReady = function() {

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

        UI.trigger('beforeready.uk.dom');

        UI.component.bootComponents();

        // custom scroll observer
        var rafToken = requestAnimationFrame((function(){

            var memory = {dir: {x:0, y:0}, x: window.pageXOffset, y:window.pageYOffset};

            var fn = function(){
                // reading this (window.page[X|Y]Offset) causes a full page recalc of the layout in Chrome,
                // so we only want to do this once
                var wpxo = window.pageXOffset;
                var wpyo = window.pageYOffset;

                // Did the scroll position change since the last time we were here?
                if (memory.x != wpxo || memory.y != wpyo) {

                    // Set the direction of the scroll and store the new position
                    if (wpxo != memory.x) {memory.dir.x = wpxo > memory.x ? 1:-1; } else { memory.dir.x = 0; }
                    if (wpyo != memory.y) {memory.dir.y = wpyo > memory.y ? 1:-1; } else { memory.dir.y = 0; }

                    memory.x = wpxo;
                    memory.y = wpyo;

                    // Trigger the scroll event, this could probably be sent using memory.clone() but this is
                    // more explicit and easier to see exactly what is being sent in the event.
                    UI.$doc.trigger('scrolling.uk.document', [{
                        dir: {x: memory.dir.x, y: memory.dir.y}, x: wpxo, y: wpyo
                    }]);
                }

                cancelAnimationFrame(rafToken);
                rafToken = requestAnimationFrame(fn);
            };

            if (UI.support.touch) {
                UI.$html.on('touchmove touchend MSPointerMove MSPointerUp pointermove pointerup', fn);
            }

            if (memory.x || memory.y) fn();

            return fn;

        })());

        // run component init functions on dom
        UI.trigger('domready.uk.dom');

        if (UI.support.touch) {

            // remove css hover rules for touch devices
            // UI.Utils.removeCssRules(/\.uk-(?!navbar).*:hover/);

            // viewport unit fix for uk-height-viewport - should be fixed in iOS 8
            if (navigator.userAgent.match(/(iPad|iPhone|iPod)/g)) {

                UI.$win.on('load orientationchange resize', UI.Utils.debounce((function(){

                    var fn = function() {
                        $('.uk-height-viewport').css('height', window.innerHeight);
                        return fn;
                    };

                    return fn();

                })(), 100));
            }
        }

        UI.trigger('afterready.uk.dom');

        // mark that domready is left behind
        UI.domready = true;

        // auto init js components
        if (UI.support.mutationobserver) {

            var initFn = UI.Utils.debounce(function(){
                requestAnimationFrame(function(){ UI.init(document.body);});
            }, 10);

            (new UI.support.mutationobserver(function(mutations) {

                var init = false;

                mutations.every(function(mutation){

                    if (mutation.type != 'childList') return true;

                    for (var i = 0, node; i < mutation.addedNodes.length; ++i) {

                        node = mutation.addedNodes[i];

                        if (node.outerHTML && node.outerHTML.indexOf('data-uk-') !== -1) {
                            return (init = true) && false;
                        }
                    }
                    return true;
                });

                if (init) initFn();

            })).observe(document.body, {childList: true, subtree: true});
        }
    };

    if (document.readyState == 'complete' || document.readyState == 'interactive') {
        setTimeout(domReady);
    }

    return domReady;

}());

// add touch identifier class
UI.$html.addClass(UI.support.touch ? 'uk-touch' : 'uk-notouch');

// add uk-hover class on tap to support overlays on touch devices
if (UI.support.touch) {

    var hoverset = false,
        exclude,
        hovercls = 'uk-hover',
        selector = '.uk-overlay, .uk-overlay-hover, .uk-overlay-toggle, .uk-animation-hover, .uk-has-hover';

    UI.$html.on('mouseenter touchstart MSPointerDown pointerdown', selector, function() {

        if (hoverset) $('.'+hovercls).removeClass(hovercls);

        hoverset = $(this).addClass(hovercls);

    }).on('mouseleave touchend MSPointerUp pointerup', function(e) {

        exclude = $(e.target).parents(selector);

        if (hoverset) {
            hoverset.not(exclude).removeClass(hovercls);
        }
    });
}

return UI;

});