var nb_var = null;
/******/ (function (modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if (installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
            /******/
        }
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
            /******/
        };
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
        /******/
    }
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function (value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function (exports, name, getter) {
/******/ 		if (!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
        /******/
    });
            /******/
        }
        /******/
    };
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function (module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
        /******/
    };
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function (object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 119);
    /******/
})
/************************************************************************/
/******/([
/* 0 */
/***/ (function (module, exports, __webpack_require__) {

        var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 * jQuery JavaScript Library v3.2.1
 * https://jquery.com/
 *
 * Includes Sizzle.js
 * https://sizzlejs.com/
 *
 * Copyright JS Foundation and other contributors
 * Released under the MIT license
 * https://jquery.org/license
 *
 * Date: 2017-03-20T18:59Z
 */
        (function (global, factory) {

            "use strict";

            if (typeof module === "object" && typeof module.exports === "object") {

                // For CommonJS and CommonJS-like environments where a proper `window`
                // is present, execute the factory and get jQuery.
                // For environments that do not have a `window` with a `document`
                // (such as Node.js), expose a factory as module.exports.
                // This accentuates the need for the creation of a real `window`.
                // e.g. var jQuery = require("jquery")(window);
                // See ticket #14549 for more info.
                module.exports = global.document ?
                    factory(global, true) :
                    function (w) {
                        if (!w.document) {
                            throw new Error("jQuery requires a window with a document");
                        }
                        return factory(w);
                    };
            } else {
                factory(global);
            }

            // Pass this if window is not defined yet
        })(typeof window !== "undefined" ? window : this, function (window, noGlobal) {

            // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
            // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
            // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
            // enough that all such attempts are guarded in a try block.
            "use strict";

            var arr = [];

            var document = window.document;

            var getProto = Object.getPrototypeOf;

            var slice = arr.slice;

            var concat = arr.concat;

            var push = arr.push;

            var indexOf = arr.indexOf;

            var class2type = {};

            var toString = class2type.toString;

            var hasOwn = class2type.hasOwnProperty;

            var fnToString = hasOwn.toString;

            var ObjectFunctionString = fnToString.call(Object);

            var support = {};



            function DOMEval(code, doc) {
                doc = doc || document;

                var script = doc.createElement("script");

                script.text = code;
                doc.head.appendChild(script).parentNode.removeChild(script);
            }
            /* global Symbol */
            // Defining this global in .eslintrc.json would create a danger of using the global
            // unguarded in another place, it seems safer to define global only for this module



            var
                version = "3.2.1",

                // Define a local copy of jQuery
                jQuery = function (selector, context) {

                    // The jQuery object is actually just the init constructor 'enhanced'
                    // Need init if jQuery is called (just allow error to be thrown if not included)
                    return new jQuery.fn.init(selector, context);
                },

                // Support: Android <=4.0 only
                // Make sure we trim BOM and NBSP
                rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,

                // Matches dashed string for camelizing
                rmsPrefix = /^-ms-/,
                rdashAlpha = /-([a-z])/g,

                // Used by jQuery.camelCase as callback to replace()
                fcamelCase = function (all, letter) {
                    return letter.toUpperCase();
                };

            jQuery.fn = jQuery.prototype = {

                // The current version of jQuery being used
                jquery: version,

                constructor: jQuery,

                // The default length of a jQuery object is 0
                length: 0,

                toArray: function () {
                    return slice.call(this);
                },

                // Get the Nth element in the matched element set OR
                // Get the whole matched element set as a clean array
                get: function (num) {

                    // Return all the elements in a clean array
                    if (num == null) {
                        return slice.call(this);
                    }

                    // Return just the one element from the set
                    return num < 0 ? this[num + this.length] : this[num];
                },

                // Take an array of elements and push it onto the stack
                // (returning the new matched element set)
                pushStack: function (elems) {

                    // Build a new jQuery matched element set
                    var ret = jQuery.merge(this.constructor(), elems);

                    // Add the old object onto the stack (as a reference)
                    ret.prevObject = this;

                    // Return the newly-formed element set
                    return ret;
                },

                // Execute a callback for every element in the matched set.
                each: function (callback) {
                    return jQuery.each(this, callback);
                },

                map: function (callback) {
                    return this.pushStack(jQuery.map(this, function (elem, i) {
                        return callback.call(elem, i, elem);
                    }));
                },

                slice: function () {
                    return this.pushStack(slice.apply(this, arguments));
                },

                first: function () {
                    return this.eq(0);
                },

                last: function () {
                    return this.eq(-1);
                },

                eq: function (i) {
                    var len = this.length,
                        j = +i + (i < 0 ? len : 0);
                    return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
                },

                end: function () {
                    return this.prevObject || this.constructor();
                },

                // For internal use only.
                // Behaves like an Array's method, not like a jQuery method.
                push: push,
                sort: arr.sort,
                splice: arr.splice
            };

            jQuery.extend = jQuery.fn.extend = function () {
                var options, name, src, copy, copyIsArray, clone,
                    target = arguments[0] || {},
                    i = 1,
                    length = arguments.length,
                    deep = false;

                // Handle a deep copy situation
                if (typeof target === "boolean") {
                    deep = target;

                    // Skip the boolean and the target
                    target = arguments[i] || {};
                    i++;
                }

                // Handle case when target is a string or something (possible in deep copy)
                if (typeof target !== "object" && !jQuery.isFunction(target)) {
                    target = {};
                }

                // Extend jQuery itself if only one argument is passed
                if (i === length) {
                    target = this;
                    i--;
                }

                for (; i < length; i++) {

                    // Only deal with non-null/undefined values
                    if ((options = arguments[i]) != null) {

                        // Extend the base object
                        for (name in options) {
                            src = target[name];
                            copy = options[name];

                            // Prevent never-ending loop
                            if (target === copy) {
                                continue;
                            }

                            // Recurse if we're merging plain objects or arrays
                            if (deep && copy && (jQuery.isPlainObject(copy) ||
                                (copyIsArray = Array.isArray(copy)))) {

                                if (copyIsArray) {
                                    copyIsArray = false;
                                    clone = src && Array.isArray(src) ? src : [];

                                } else {
                                    clone = src && jQuery.isPlainObject(src) ? src : {};
                                }

                                // Never move original objects, clone them
                                target[name] = jQuery.extend(deep, clone, copy);

                                // Don't bring in undefined values
                            } else if (copy !== undefined) {
                                target[name] = copy;
                            }
                        }
                    }
                }

                // Return the modified object
                return target;
            };

            jQuery.extend({

                // Unique for each copy of jQuery on the page
                expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),

                // Assume jQuery is ready without the ready module
                isReady: true,

                error: function (msg) {
                    throw new Error(msg);
                },

                noop: function () { },

                isFunction: function (obj) {
                    return jQuery.type(obj) === "function";
                },

                isWindow: function (obj) {
                    return obj != null && obj === obj.window;
                },

                isNumeric: function (obj) {

                    // As of jQuery 3.0, isNumeric is limited to
                    // strings and numbers (primitives or objects)
                    // that can be coerced to finite numbers (gh-2662)
                    var type = jQuery.type(obj);
                    return (type === "number" || type === "string") &&

                        // parseFloat NaNs numeric-cast false positives ("")
                        // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
                        // subtraction forces infinities to NaN
                        !isNaN(obj - parseFloat(obj));
                },

                isPlainObject: function (obj) {
                    var proto, Ctor;

                    // Detect obvious negatives
                    // Use toString instead of jQuery.type to catch host objects
                    if (!obj || toString.call(obj) !== "[object Object]") {
                        return false;
                    }

                    proto = getProto(obj);

                    // Objects with no prototype (e.g., `Object.create( null )`) are plain
                    if (!proto) {
                        return true;
                    }

                    // Objects with prototype are plain iff they were constructed by a global Object function
                    Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
                    return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
                },

                isEmptyObject: function (obj) {

                    /* eslint-disable no-unused-vars */
                    // See https://github.com/eslint/eslint/issues/6125
                    var name;

                    for (name in obj) {
                        return false;
                    }
                    return true;
                },

                type: function (obj) {
                    if (obj == null) {
                        return obj + "";
                    }

                    // Support: Android <=2.3 only (functionish RegExp)
                    return typeof obj === "object" || typeof obj === "function" ?
                        class2type[toString.call(obj)] || "object" :
                        typeof obj;
                },

                // Evaluates a script in a global context
                globalEval: function (code) {
                    DOMEval(code);
                },

                // Convert dashed to camelCase; used by the css and data modules
                // Support: IE <=9 - 11, Edge 12 - 13
                // Microsoft forgot to hump their vendor prefix (#9572)
                camelCase: function (string) {
                    return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
                },

                each: function (obj, callback) {
                    var length, i = 0;

                    if (isArrayLike(obj)) {
                        length = obj.length;
                        for (; i < length; i++) {
                            if (callback.call(obj[i], i, obj[i]) === false) {
                                break;
                            }
                        }
                    } else {
                        for (i in obj) {
                            if (callback.call(obj[i], i, obj[i]) === false) {
                                break;
                            }
                        }
                    }

                    return obj;
                },

                // Support: Android <=4.0 only
                trim: function (text) {
                    return text == null ?
                        "" :
                        (text + "").replace(rtrim, "");
                },

                // results is for internal usage only
                makeArray: function (arr, results) {
                    var ret = results || [];

                    if (arr != null) {
                        if (isArrayLike(Object(arr))) {
                            jQuery.merge(ret,
                                typeof arr === "string" ?
                                    [arr] : arr
                            );
                        } else {
                            push.call(ret, arr);
                        }
                    }

                    return ret;
                },

                inArray: function (elem, arr, i) {
                    return arr == null ? -1 : indexOf.call(arr, elem, i);
                },

                // Support: Android <=4.0 only, PhantomJS 1 only
                // push.apply(_, arraylike) throws on ancient WebKit
                merge: function (first, second) {
                    var len = +second.length,
                        j = 0,
                        i = first.length;

                    for (; j < len; j++) {
                        first[i++] = second[j];
                    }

                    first.length = i;

                    return first;
                },

                grep: function (elems, callback, invert) {
                    var callbackInverse,
                        matches = [],
                        i = 0,
                        length = elems.length,
                        callbackExpect = !invert;

                    // Go through the array, only saving the items
                    // that pass the validator function
                    for (; i < length; i++) {
                        callbackInverse = !callback(elems[i], i);
                        if (callbackInverse !== callbackExpect) {
                            matches.push(elems[i]);
                        }
                    }

                    return matches;
                },

                // arg is for internal usage only
                map: function (elems, callback, arg) {
                    var length, value,
                        i = 0,
                        ret = [];

                    // Go through the array, translating each of the items to their new values
                    if (isArrayLike(elems)) {
                        length = elems.length;
                        for (; i < length; i++) {
                            value = callback(elems[i], i, arg);

                            if (value != null) {
                                ret.push(value);
                            }
                        }

                        // Go through every key on the object,
                    } else {
                        for (i in elems) {
                            value = callback(elems[i], i, arg);

                            if (value != null) {
                                ret.push(value);
                            }
                        }
                    }

                    // Flatten any nested arrays
                    return concat.apply([], ret);
                },

                // A global GUID counter for objects
                guid: 1,

                // Bind a function to a context, optionally partially applying any
                // arguments.
                proxy: function (fn, context) {
                    var tmp, args, proxy;

                    if (typeof context === "string") {
                        tmp = fn[context];
                        context = fn;
                        fn = tmp;
                    }

                    // Quick check to determine if target is callable, in the spec
                    // this throws a TypeError, but we will just return undefined.
                    if (!jQuery.isFunction(fn)) {
                        return undefined;
                    }

                    // Simulated bind
                    args = slice.call(arguments, 2);
                    proxy = function () {
                        return fn.apply(context || this, args.concat(slice.call(arguments)));
                    };

                    // Set the guid of unique handler to the same of original handler, so it can be removed
                    proxy.guid = fn.guid = fn.guid || jQuery.guid++;

                    return proxy;
                },

                now: Date.now,

                // jQuery.support is not used in Core but other projects attach their
                // properties to it so it needs to exist.
                support: support
            });

            if (typeof Symbol === "function") {
                jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
            }

            // Populate the class2type map
            jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),
                function (i, name) {
                    class2type["[object " + name + "]"] = name.toLowerCase();
                });

            function isArrayLike(obj) {

                // Support: real iOS 8.2 only (not reproducible in simulator)
                // `in` check used to prevent JIT error (gh-2145)
                // hasOwn isn't used here due to false negatives
                // regarding Nodelist length in IE
                var length = !!obj && "length" in obj && obj.length,
                    type = jQuery.type(obj);

                if (type === "function" || jQuery.isWindow(obj)) {
                    return false;
                }

                return type === "array" || length === 0 ||
                    typeof length === "number" && length > 0 && (length - 1) in obj;
            }
            var Sizzle =
                /*!
                 * Sizzle CSS Selector Engine v2.3.3
                 * https://sizzlejs.com/
                 *
                 * Copyright jQuery Foundation and other contributors
                 * Released under the MIT license
                 * http://jquery.org/license
                 *
                 * Date: 2016-08-08
                 */
                (function (window) {

                    var i,
                        support,
                        Expr,
                        getText,
                        isXML,
                        tokenize,
                        compile,
                        select,
                        outermostContext,
                        sortInput,
                        hasDuplicate,

                        // Local document vars
                        setDocument,
                        document,
                        docElem,
                        documentIsHTML,
                        rbuggyQSA,
                        rbuggyMatches,
                        matches,
                        contains,

                        // Instance-specific data
                        expando = "sizzle" + 1 * new Date(),
                        preferredDoc = window.document,
                        dirruns = 0,
                        done = 0,
                        classCache = createCache(),
                        tokenCache = createCache(),
                        compilerCache = createCache(),
                        sortOrder = function (a, b) {
                            if (a === b) {
                                hasDuplicate = true;
                            }
                            return 0;
                        },

                        // Instance methods
                        hasOwn = ({}).hasOwnProperty,
                        arr = [],
                        pop = arr.pop,
                        push_native = arr.push,
                        push = arr.push,
                        slice = arr.slice,
                        // Use a stripped-down indexOf as it's faster than native
                        // https://jsperf.com/thor-indexof-vs-for/5
                        indexOf = function (list, elem) {
                            var i = 0,
                                len = list.length;
                            for (; i < len; i++) {
                                if (list[i] === elem) {
                                    return i;
                                }
                            }
                            return -1;
                        },

                        booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",

                        // Regular expressions

                        // http://www.w3.org/TR/css3-selectors/#whitespace
                        whitespace = "[\\x20\\t\\r\\n\\f]",

                        // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
                        identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",

                        // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
                        attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
                            // Operator (capture 2)
                            "*([*^$|!~]?=)" + whitespace +
                            // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
                            "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
                            "*\\]",

                        pseudos = ":(" + identifier + ")(?:\\((" +
                            // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
                            // 1. quoted (capture 3; capture 4 or capture 5)
                            "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
                            // 2. simple (capture 6)
                            "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
                            // 3. anything else (capture 2)
                            ".*" +
                            ")\\)|)",

                        // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
                        rwhitespace = new RegExp(whitespace + "+", "g"),
                        rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),

                        rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
                        rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),

                        rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"),

                        rpseudo = new RegExp(pseudos),
                        ridentifier = new RegExp("^" + identifier + "$"),

                        matchExpr = {
                            "ID": new RegExp("^#(" + identifier + ")"),
                            "CLASS": new RegExp("^\\.(" + identifier + ")"),
                            "TAG": new RegExp("^(" + identifier + "|[*])"),
                            "ATTR": new RegExp("^" + attributes),
                            "PSEUDO": new RegExp("^" + pseudos),
                            "CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
                                "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
                                "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
                            "bool": new RegExp("^(?:" + booleans + ")$", "i"),
                            // For use in libraries implementing .is()
                            // We use this for POS matching in `select`
                            "needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
                                whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
                        },

                        rinputs = /^(?:input|select|textarea|button)$/i,
                        rheader = /^h\d$/i,

                        rnative = /^[^{]+\{\s*\[native \w/,

                        // Easily-parseable/retrievable ID or TAG or CLASS selectors
                        rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

                        rsibling = /[+~]/,

                        // CSS escapes
                        // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
                        runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
                        funescape = function (_, escaped, escapedWhitespace) {
                            var high = "0x" + escaped - 0x10000;
                            // NaN means non-codepoint
                            // Support: Firefox<24
                            // Workaround erroneous numeric interpretation of +"0x"
                            return high !== high || escapedWhitespace ?
                                escaped :
                                high < 0 ?
                                    // BMP codepoint
                                    String.fromCharCode(high + 0x10000) :
                                    // Supplemental Plane codepoint (surrogate pair)
                                    String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
                        },

                        // CSS string/identifier serialization
                        // https://drafts.csswg.org/cssom/#common-serializing-idioms
                        rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
                        fcssescape = function (ch, asCodePoint) {
                            if (asCodePoint) {

                                // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
                                if (ch === "\0") {
                                    return "\uFFFD";
                                }

                                // Control characters and (dependent upon position) numbers get escaped as code points
                                return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
                            }

                            // Other potentially-special ASCII characters get backslash-escaped
                            return "\\" + ch;
                        },

                        // Used for iframes
                        // See setDocument()
                        // Removing the function wrapper causes a "Permission Denied"
                        // error in IE
                        unloadHandler = function () {
                            setDocument();
                        },

                        disabledAncestor = addCombinator(
                            function (elem) {
                                return elem.disabled === true && ("form" in elem || "label" in elem);
                            },
                            { dir: "parentNode", next: "legend" }
                        );

                    // Optimize for push.apply( _, NodeList )
                    try {
                        push.apply(
                            (arr = slice.call(preferredDoc.childNodes)),
                            preferredDoc.childNodes
                        );
                        // Support: Android<4.0
                        // Detect silently failing push.apply
                        arr[preferredDoc.childNodes.length].nodeType;
                    } catch (e) {
                        push = {
                            apply: arr.length ?

                                // Leverage slice if possible
                                function (target, els) {
                                    push_native.apply(target, slice.call(els));
                                } :

                                // Support: IE<9
                                // Otherwise append directly
                                function (target, els) {
                                    var j = target.length,
                                        i = 0;
                                    // Can't trust NodeList.length
                                    while ((target[j++] = els[i++])) { }
                                    target.length = j - 1;
                                }
                        };
                    }

                    function Sizzle(selector, context, results, seed) {
                        var m, i, elem, nid, match, groups, newSelector,
                            newContext = context && context.ownerDocument,

                            // nodeType defaults to 9, since context defaults to document
                            nodeType = context ? context.nodeType : 9;

                        results = results || [];

                        // Return early from calls with invalid selector or context
                        if (typeof selector !== "string" || !selector ||
                            nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {

                            return results;
                        }

                        // Try to shortcut find operations (as opposed to filters) in HTML documents
                        if (!seed) {

                            if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
                                setDocument(context);
                            }
                            context = context || document;

                            if (documentIsHTML) {

                                // If the selector is sufficiently simple, try using a "get*By*" DOM method
                                // (excepting DocumentFragment context, where the methods don't exist)
                                if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {

                                    // ID selector
                                    if ((m = match[1])) {

                                        // Document context
                                        if (nodeType === 9) {
                                            if ((elem = context.getElementById(m))) {

                                                // Support: IE, Opera, Webkit
                                                // TODO: identify versions
                                                // getElementById can match elements by name instead of ID
                                                if (elem.id === m) {
                                                    results.push(elem);
                                                    return results;
                                                }
                                            } else {
                                                return results;
                                            }

                                            // Element context
                                        } else {

                                            // Support: IE, Opera, Webkit
                                            // TODO: identify versions
                                            // getElementById can match elements by name instead of ID
                                            if (newContext && (elem = newContext.getElementById(m)) &&
                                                contains(context, elem) &&
                                                elem.id === m) {

                                                results.push(elem);
                                                return results;
                                            }
                                        }

                                        // Type selector
                                    } else if (match[2]) {
                                        push.apply(results, context.getElementsByTagName(selector));
                                        return results;

                                        // Class selector
                                    } else if ((m = match[3]) && support.getElementsByClassName &&
                                        context.getElementsByClassName) {

                                        push.apply(results, context.getElementsByClassName(m));
                                        return results;
                                    }
                                }

                                // Take advantage of querySelectorAll
                                if (support.qsa &&
                                    !compilerCache[selector + " "] &&
                                    (!rbuggyQSA || !rbuggyQSA.test(selector))) {

                                    if (nodeType !== 1) {
                                        newContext = context;
                                        newSelector = selector;

                                        // qSA looks outside Element context, which is not what we want
                                        // Thanks to Andrew Dupont for this workaround technique
                                        // Support: IE <=8
                                        // Exclude object elements
                                    } else if (context.nodeName.toLowerCase() !== "object") {

                                        // Capture the context ID, setting it first if necessary
                                        if ((nid = context.getAttribute("id"))) {
                                            nid = nid.replace(rcssescape, fcssescape);
                                        } else {
                                            context.setAttribute("id", (nid = expando));
                                        }

                                        // Prefix every selector in the list
                                        groups = tokenize(selector);
                                        i = groups.length;
                                        while (i--) {
                                            groups[i] = "#" + nid + " " + toSelector(groups[i]);
                                        }
                                        newSelector = groups.join(",");

                                        // Expand context for sibling selectors
                                        newContext = rsibling.test(selector) && testContext(context.parentNode) ||
                                            context;
                                    }

                                    if (newSelector) {
                                        try {
                                            push.apply(results,
                                                newContext.querySelectorAll(newSelector)
                                            );
                                            return results;
                                        } catch (qsaError) {
                                        } finally {
                                            if (nid === expando) {
                                                context.removeAttribute("id");
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        // All others
                        return select(selector.replace(rtrim, "$1"), context, results, seed);
                    }

                    /**
                     * Create key-value caches of limited size
                     * @returns {function(string, object)} Returns the Object data after storing it on itself with
                     *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
                     *	deleting the oldest entry
                     */
                    function createCache() {
                        var keys = [];

                        function cache(key, value) {
                            // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
                            if (keys.push(key + " ") > Expr.cacheLength) {
                                // Only keep the most recent entries
                                delete cache[keys.shift()];
                            }
                            return (cache[key + " "] = value);
                        }
                        return cache;
                    }

                    /**
                     * Mark a function for special use by Sizzle
                     * @param {Function} fn The function to mark
                     */
                    function markFunction(fn) {
                        fn[expando] = true;
                        return fn;
                    }

                    /**
                     * Support testing using an element
                     * @param {Function} fn Passed the created element and returns a boolean result
                     */
                    function assert(fn) {
                        var el = document.createElement("fieldset");

                        try {
                            return !!fn(el);
                        } catch (e) {
                            return false;
                        } finally {
                            // Remove from its parent by default
                            if (el.parentNode) {
                                el.parentNode.removeChild(el);
                            }
                            // release memory in IE
                            el = null;
                        }
                    }

                    /**
                     * Adds the same handler for all of the specified attrs
                     * @param {String} attrs Pipe-separated list of attributes
                     * @param {Function} handler The method that will be applied
                     */
                    function addHandle(attrs, handler) {
                        var arr = attrs.split("|"),
                            i = arr.length;

                        while (i--) {
                            Expr.attrHandle[arr[i]] = handler;
                        }
                    }

                    /**
                     * Checks document order of two siblings
                     * @param {Element} a
                     * @param {Element} b
                     * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
                     */
                    function siblingCheck(a, b) {
                        var cur = b && a,
                            diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
                                a.sourceIndex - b.sourceIndex;

                        // Use IE sourceIndex if available on both nodes
                        if (diff) {
                            return diff;
                        }

                        // Check if b follows a
                        if (cur) {
                            while ((cur = cur.nextSibling)) {
                                if (cur === b) {
                                    return -1;
                                }
                            }
                        }

                        return a ? 1 : -1;
                    }

                    /**
                     * Returns a function to use in pseudos for input types
                     * @param {String} type
                     */
                    function createInputPseudo(type) {
                        return function (elem) {
                            var name = elem.nodeName.toLowerCase();
                            return name === "input" && elem.type === type;
                        };
                    }

                    /**
                     * Returns a function to use in pseudos for buttons
                     * @param {String} type
                     */
                    function createButtonPseudo(type) {
                        return function (elem) {
                            var name = elem.nodeName.toLowerCase();
                            return (name === "input" || name === "button") && elem.type === type;
                        };
                    }

                    /**
                     * Returns a function to use in pseudos for :enabled/:disabled
                     * @param {Boolean} disabled true for :disabled; false for :enabled
                     */
                    function createDisabledPseudo(disabled) {

                        // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
                        return function (elem) {

                            // Only certain elements can match :enabled or :disabled
                            // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
                            // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
                            if ("form" in elem) {

                                // Check for inherited disabledness on relevant non-disabled elements:
                                // * listed form-associated elements in a disabled fieldset
                                //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
                                //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
                                // * option elements in a disabled optgroup
                                //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
                                // All such elements have a "form" property.
                                if (elem.parentNode && elem.disabled === false) {

                                    // Option elements defer to a parent optgroup if present
                                    if ("label" in elem) {
                                        if ("label" in elem.parentNode) {
                                            return elem.parentNode.disabled === disabled;
                                        } else {
                                            return elem.disabled === disabled;
                                        }
                                    }

                                    // Support: IE 6 - 11
                                    // Use the isDisabled shortcut property to check for disabled fieldset ancestors
                                    return elem.isDisabled === disabled ||

                                        // Where there is no isDisabled, check manually
                                        /* jshint -W018 */
                                        elem.isDisabled !== !disabled &&
                                        disabledAncestor(elem) === disabled;
                                }

                                return elem.disabled === disabled;

                                // Try to winnow out elements that can't be disabled before trusting the disabled property.
                                // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
                                // even exist on them, let alone have a boolean value.
                            } else if ("label" in elem) {
                                return elem.disabled === disabled;
                            }

                            // Remaining elements are neither :enabled nor :disabled
                            return false;
                        };
                    }

                    /**
                     * Returns a function to use in pseudos for positionals
                     * @param {Function} fn
                     */
                    function createPositionalPseudo(fn) {
                        return markFunction(function (argument) {
                            argument = +argument;
                            return markFunction(function (seed, matches) {
                                var j,
                                    matchIndexes = fn([], seed.length, argument),
                                    i = matchIndexes.length;

                                // Match elements found at the specified indexes
                                while (i--) {
                                    if (seed[(j = matchIndexes[i])]) {
                                        seed[j] = !(matches[j] = seed[j]);
                                    }
                                }
                            });
                        });
                    }

                    /**
                     * Checks a node for validity as a Sizzle context
                     * @param {Element|Object=} context
                     * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
                     */
                    function testContext(context) {
                        return context && typeof context.getElementsByTagName !== "undefined" && context;
                    }

                    // Expose support vars for convenience
                    support = Sizzle.support = {};

                    /**
                     * Detects XML nodes
                     * @param {Element|Object} elem An element or a document
                     * @returns {Boolean} True iff elem is a non-HTML XML node
                     */
                    isXML = Sizzle.isXML = function (elem) {
                        // documentElement is verified for cases where it doesn't yet exist
                        // (such as loading iframes in IE - #4833)
                        var documentElement = elem && (elem.ownerDocument || elem).documentElement;
                        return documentElement ? documentElement.nodeName !== "HTML" : false;
                    };

                    /**
                     * Sets document-related variables once based on the current document
                     * @param {Element|Object} [doc] An element or document object to use to set the document
                     * @returns {Object} Returns the current document
                     */
                    setDocument = Sizzle.setDocument = function (node) {
                        var hasCompare, subWindow,
                            doc = node ? node.ownerDocument || node : preferredDoc;

                        // Return early if doc is invalid or already selected
                        if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
                            return document;
                        }

                        // Update global variables
                        document = doc;
                        docElem = document.documentElement;
                        documentIsHTML = !isXML(document);

                        // Support: IE 9-11, Edge
                        // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
                        if (preferredDoc !== document &&
                            (subWindow = document.defaultView) && subWindow.top !== subWindow) {

                            // Support: IE 11, Edge
                            if (subWindow.addEventListener) {
                                subWindow.addEventListener("unload", unloadHandler, false);

                                // Support: IE 9 - 10 only
                            } else if (subWindow.attachEvent) {
                                subWindow.attachEvent("onunload", unloadHandler);
                            }
                        }

                        /* Attributes
                        ---------------------------------------------------------------------- */

                        // Support: IE<8
                        // Verify that getAttribute really returns attributes and not properties
                        // (excepting IE8 booleans)
                        support.attributes = assert(function (el) {
                            el.className = "i";
                            return !el.getAttribute("className");
                        });

                        /* getElement(s)By*
                        ---------------------------------------------------------------------- */

                        // Check if getElementsByTagName("*") returns only elements
                        support.getElementsByTagName = assert(function (el) {
                            el.appendChild(document.createComment(""));
                            return !el.getElementsByTagName("*").length;
                        });

                        // Support: IE<9
                        support.getElementsByClassName = rnative.test(document.getElementsByClassName);

                        // Support: IE<10
                        // Check if getElementById returns elements by name
                        // The broken getElementById methods don't pick up programmatically-set names,
                        // so use a roundabout getElementsByName test
                        support.getById = assert(function (el) {
                            docElem.appendChild(el).id = expando;
                            return !document.getElementsByName || !document.getElementsByName(expando).length;
                        });

                        // ID filter and find
                        if (support.getById) {
                            Expr.filter["ID"] = function (id) {
                                var attrId = id.replace(runescape, funescape);
                                return function (elem) {
                                    return elem.getAttribute("id") === attrId;
                                };
                            };
                            Expr.find["ID"] = function (id, context) {
                                if (typeof context.getElementById !== "undefined" && documentIsHTML) {
                                    var elem = context.getElementById(id);
                                    return elem ? [elem] : [];
                                }
                            };
                        } else {
                            Expr.filter["ID"] = function (id) {
                                var attrId = id.replace(runescape, funescape);
                                return function (elem) {
                                    var node = typeof elem.getAttributeNode !== "undefined" &&
                                        elem.getAttributeNode("id");
                                    return node && node.value === attrId;
                                };
                            };

                            // Support: IE 6 - 7 only
                            // getElementById is not reliable as a find shortcut
                            Expr.find["ID"] = function (id, context) {
                                if (typeof context.getElementById !== "undefined" && documentIsHTML) {
                                    var node, i, elems,
                                        elem = context.getElementById(id);

                                    if (elem) {

                                        // Verify the id attribute
                                        node = elem.getAttributeNode("id");
                                        if (node && node.value === id) {
                                            return [elem];
                                        }

                                        // Fall back on getElementsByName
                                        elems = context.getElementsByName(id);
                                        i = 0;
                                        while ((elem = elems[i++])) {
                                            node = elem.getAttributeNode("id");
                                            if (node && node.value === id) {
                                                return [elem];
                                            }
                                        }
                                    }

                                    return [];
                                }
                            };
                        }

                        // Tag
                        Expr.find["TAG"] = support.getElementsByTagName ?
                            function (tag, context) {
                                if (typeof context.getElementsByTagName !== "undefined") {
                                    return context.getElementsByTagName(tag);

                                    // DocumentFragment nodes don't have gEBTN
                                } else if (support.qsa) {
                                    return context.querySelectorAll(tag);
                                }
                            } :

                            function (tag, context) {
                                var elem,
                                    tmp = [],
                                    i = 0,
                                    // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
                                    results = context.getElementsByTagName(tag);

                                // Filter out possible comments
                                if (tag === "*") {
                                    while ((elem = results[i++])) {
                                        if (elem.nodeType === 1) {
                                            tmp.push(elem);
                                        }
                                    }

                                    return tmp;
                                }
                                return results;
                            };

                        // Class
                        Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
                            if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
                                return context.getElementsByClassName(className);
                            }
                        };

                        /* QSA/matchesSelector
                        ---------------------------------------------------------------------- */

                        // QSA and matchesSelector support

                        // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
                        rbuggyMatches = [];

                        // qSa(:focus) reports false when true (Chrome 21)
                        // We allow this because of a bug in IE8/9 that throws an error
                        // whenever `document.activeElement` is accessed on an iframe
                        // So, we allow :focus to pass through QSA all the time to avoid the IE error
                        // See https://bugs.jquery.com/ticket/13378
                        rbuggyQSA = [];

                        if ((support.qsa = rnative.test(document.querySelectorAll))) {
                            // Build QSA regex
                            // Regex strategy adopted from Diego Perini
                            assert(function (el) {
                                // Select is set to empty string on purpose
                                // This is to test IE's treatment of not explicitly
                                // setting a boolean content attribute,
                                // since its presence should be enough
                                // https://bugs.jquery.com/ticket/12359
                                docElem.appendChild(el).innerHTML = "<a id='" + expando + "'></a>" +
                                    "<select id='" + expando + "-\r\\' msallowcapture=''>" +
                                    "<option selected=''></option></select>";

                                // Support: IE8, Opera 11-12.16
                                // Nothing should be selected when empty strings follow ^= or $= or *=
                                // The test attribute must be unknown in Opera but "safe" for WinRT
                                // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
                                if (el.querySelectorAll("[msallowcapture^='']").length) {
                                    rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
                                }

                                // Support: IE8
                                // Boolean attributes and "value" are not treated correctly
                                if (!el.querySelectorAll("[selected]").length) {
                                    rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
                                }

                                // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
                                if (!el.querySelectorAll("[id~=" + expando + "-]").length) {
                                    rbuggyQSA.push("~=");
                                }

                                // Webkit/Opera - :checked should return selected option elements
                                // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
                                // IE8 throws error here and will not see later tests
                                if (!el.querySelectorAll(":checked").length) {
                                    rbuggyQSA.push(":checked");
                                }

                                // Support: Safari 8+, iOS 8+
                                // https://bugs.webkit.org/show_bug.cgi?id=136851
                                // In-page `selector#id sibling-combinator selector` fails
                                if (!el.querySelectorAll("a#" + expando + "+*").length) {
                                    rbuggyQSA.push(".#.+[+~]");
                                }
                            });

                            assert(function (el) {
                                el.innerHTML = "<a href='' disabled='disabled'></a>" +
                                    "<select disabled='disabled'><option/></select>";

                                // Support: Windows 8 Native Apps
                                // The type and name attributes are restricted during .innerHTML assignment
                                var input = document.createElement("input");
                                input.setAttribute("type", "hidden");
                                el.appendChild(input).setAttribute("name", "D");

                                // Support: IE8
                                // Enforce case-sensitivity of name attribute
                                if (el.querySelectorAll("[name=d]").length) {
                                    rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
                                }

                                // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
                                // IE8 throws error here and will not see later tests
                                if (el.querySelectorAll(":enabled").length !== 2) {
                                    rbuggyQSA.push(":enabled", ":disabled");
                                }

                                // Support: IE9-11+
                                // IE's :disabled selector does not pick up the children of disabled fieldsets
                                docElem.appendChild(el).disabled = true;
                                if (el.querySelectorAll(":disabled").length !== 2) {
                                    rbuggyQSA.push(":enabled", ":disabled");
                                }

                                // Opera 10-11 does not throw on post-comma invalid pseudos
                                el.querySelectorAll("*,:x");
                                rbuggyQSA.push(",.*:");
                            });
                        }

                        if ((support.matchesSelector = rnative.test((matches = docElem.matches ||
                            docElem.webkitMatchesSelector ||
                            docElem.mozMatchesSelector ||
                            docElem.oMatchesSelector ||
                            docElem.msMatchesSelector)))) {

                            assert(function (el) {
                                // Check to see if it's possible to do matchesSelector
                                // on a disconnected node (IE 9)
                                support.disconnectedMatch = matches.call(el, "*");

                                // This should fail with an exception
                                // Gecko does not error, returns false instead
                                matches.call(el, "[s!='']:x");
                                rbuggyMatches.push("!=", pseudos);
                            });
                        }

                        rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
                        rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));

                        /* Contains
                        ---------------------------------------------------------------------- */
                        hasCompare = rnative.test(docElem.compareDocumentPosition);

                        // Element contains another
                        // Purposefully self-exclusive
                        // As in, an element does not contain itself
                        contains = hasCompare || rnative.test(docElem.contains) ?
                            function (a, b) {
                                var adown = a.nodeType === 9 ? a.documentElement : a,
                                    bup = b && b.parentNode;
                                return a === bup || !!(bup && bup.nodeType === 1 && (
                                    adown.contains ?
                                        adown.contains(bup) :
                                        a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16
                                ));
                            } :
                            function (a, b) {
                                if (b) {
                                    while ((b = b.parentNode)) {
                                        if (b === a) {
                                            return true;
                                        }
                                    }
                                }
                                return false;
                            };

                        /* Sorting
                        ---------------------------------------------------------------------- */

                        // Document order sorting
                        sortOrder = hasCompare ?
                            function (a, b) {

                                // Flag for duplicate removal
                                if (a === b) {
                                    hasDuplicate = true;
                                    return 0;
                                }

                                // Sort on method existence if only one input has compareDocumentPosition
                                var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
                                if (compare) {
                                    return compare;
                                }

                                // Calculate position if both inputs belong to the same document
                                compare = (a.ownerDocument || a) === (b.ownerDocument || b) ?
                                    a.compareDocumentPosition(b) :

                                    // Otherwise we know they are disconnected
                                    1;

                                // Disconnected nodes
                                if (compare & 1 ||
                                    (!support.sortDetached && b.compareDocumentPosition(a) === compare)) {

                                    // Choose the first element that is related to our preferred document
                                    if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
                                        return -1;
                                    }
                                    if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
                                        return 1;
                                    }

                                    // Maintain original order
                                    return sortInput ?
                                        (indexOf(sortInput, a) - indexOf(sortInput, b)) :
                                        0;
                                }

                                return compare & 4 ? -1 : 1;
                            } :
                            function (a, b) {
                                // Exit early if the nodes are identical
                                if (a === b) {
                                    hasDuplicate = true;
                                    return 0;
                                }

                                var cur,
                                    i = 0,
                                    aup = a.parentNode,
                                    bup = b.parentNode,
                                    ap = [a],
                                    bp = [b];

                                // Parentless nodes are either documents or disconnected
                                if (!aup || !bup) {
                                    return a === document ? -1 :
                                        b === document ? 1 :
                                            aup ? -1 :
                                                bup ? 1 :
                                                    sortInput ?
                                                        (indexOf(sortInput, a) - indexOf(sortInput, b)) :
                                                        0;

                                    // If the nodes are siblings, we can do a quick check
                                } else if (aup === bup) {
                                    return siblingCheck(a, b);
                                }

                                // Otherwise we need full lists of their ancestors for comparison
                                cur = a;
                                while ((cur = cur.parentNode)) {
                                    ap.unshift(cur);
                                }
                                cur = b;
                                while ((cur = cur.parentNode)) {
                                    bp.unshift(cur);
                                }

                                // Walk down the tree looking for a discrepancy
                                while (ap[i] === bp[i]) {
                                    i++;
                                }

                                return i ?
                                    // Do a sibling check if the nodes have a common ancestor
                                    siblingCheck(ap[i], bp[i]) :

                                    // Otherwise nodes in our document sort first
                                    ap[i] === preferredDoc ? -1 :
                                        bp[i] === preferredDoc ? 1 :
                                            0;
                            };

                        return document;
                    };

                    Sizzle.matches = function (expr, elements) {
                        return Sizzle(expr, null, null, elements);
                    };

                    Sizzle.matchesSelector = function (elem, expr) {
                        // Set document vars if needed
                        if ((elem.ownerDocument || elem) !== document) {
                            setDocument(elem);
                        }

                        // Make sure that attribute selectors are quoted
                        expr = expr.replace(rattributeQuotes, "='$1']");

                        if (support.matchesSelector && documentIsHTML &&
                            !compilerCache[expr + " "] &&
                            (!rbuggyMatches || !rbuggyMatches.test(expr)) &&
                            (!rbuggyQSA || !rbuggyQSA.test(expr))) {

                            try {
                                var ret = matches.call(elem, expr);

                                // IE 9's matchesSelector returns false on disconnected nodes
                                if (ret || support.disconnectedMatch ||
                                    // As well, disconnected nodes are said to be in a document
                                    // fragment in IE 9
                                    elem.document && elem.document.nodeType !== 11) {
                                    return ret;
                                }
                            } catch (e) { }
                        }

                        return Sizzle(expr, document, null, [elem]).length > 0;
                    };

                    Sizzle.contains = function (context, elem) {
                        // Set document vars if needed
                        if ((context.ownerDocument || context) !== document) {
                            setDocument(context);
                        }
                        return contains(context, elem);
                    };

                    Sizzle.attr = function (elem, name) {
                        // Set document vars if needed
                        if ((elem.ownerDocument || elem) !== document) {
                            setDocument(elem);
                        }

                        var fn = Expr.attrHandle[name.toLowerCase()],
                            // Don't get fooled by Object.prototype properties (jQuery #13807)
                            val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ?
                                fn(elem, name, !documentIsHTML) :
                                undefined;

                        return val !== undefined ?
                            val :
                            support.attributes || !documentIsHTML ?
                                elem.getAttribute(name) :
                                (val = elem.getAttributeNode(name)) && val.specified ?
                                    val.value :
                                    null;
                    };

                    Sizzle.escape = function (sel) {
                        return (sel + "").replace(rcssescape, fcssescape);
                    };

                    Sizzle.error = function (msg) {
                        throw new Error("Syntax error, unrecognized expression: " + msg);
                    };

                    /**
                     * Document sorting and removing duplicates
                     * @param {ArrayLike} results
                     */
                    Sizzle.uniqueSort = function (results) {
                        var elem,
                            duplicates = [],
                            j = 0,
                            i = 0;

                        // Unless we *know* we can detect duplicates, assume their presence
                        hasDuplicate = !support.detectDuplicates;
                        sortInput = !support.sortStable && results.slice(0);
                        results.sort(sortOrder);

                        if (hasDuplicate) {
                            while ((elem = results[i++])) {
                                if (elem === results[i]) {
                                    j = duplicates.push(i);
                                }
                            }
                            while (j--) {
                                results.splice(duplicates[j], 1);
                            }
                        }

                        // Clear input after sorting to release objects
                        // See https://github.com/jquery/sizzle/pull/225
                        sortInput = null;

                        return results;
                    };

                    /**
                     * Utility function for retrieving the text value of an array of DOM nodes
                     * @param {Array|Element} elem
                     */
                    getText = Sizzle.getText = function (elem) {
                        var node,
                            ret = "",
                            i = 0,
                            nodeType = elem.nodeType;

                        if (!nodeType) {
                            // If no nodeType, this is expected to be an array
                            while ((node = elem[i++])) {
                                // Do not traverse comment nodes
                                ret += getText(node);
                            }
                        } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
                            // Use textContent for elements
                            // innerText usage removed for consistency of new lines (jQuery #11153)
                            if (typeof elem.textContent === "string") {
                                return elem.textContent;
                            } else {
                                // Traverse its children
                                for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
                                    ret += getText(elem);
                                }
                            }
                        } else if (nodeType === 3 || nodeType === 4) {
                            return elem.nodeValue;
                        }
                        // Do not include comment or processing instruction nodes

                        return ret;
                    };

                    Expr = Sizzle.selectors = {

                        // Can be adjusted by the user
                        cacheLength: 50,

                        createPseudo: markFunction,

                        match: matchExpr,

                        attrHandle: {},

                        find: {},

                        relative: {
                            ">": { dir: "parentNode", first: true },
                            " ": { dir: "parentNode" },
                            "+": { dir: "previousSibling", first: true },
                            "~": { dir: "previousSibling" }
                        },

                        preFilter: {
                            "ATTR": function (match) {
                                match[1] = match[1].replace(runescape, funescape);

                                // Move the given value to match[3] whether quoted or unquoted
                                match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);

                                if (match[2] === "~=") {
                                    match[3] = " " + match[3] + " ";
                                }

                                return match.slice(0, 4);
                            },

                            "CHILD": function (match) {
                                /* matches from matchExpr["CHILD"]
                                    1 type (only|nth|...)
                                    2 what (child|of-type)
                                    3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
                                    4 xn-component of xn+y argument ([+-]?\d*n|)
                                    5 sign of xn-component
                                    6 x of xn-component
                                    7 sign of y-component
                                    8 y of y-component
                                */
                                match[1] = match[1].toLowerCase();

                                if (match[1].slice(0, 3) === "nth") {
                                    // nth-* requires argument
                                    if (!match[3]) {
                                        Sizzle.error(match[0]);
                                    }

                                    // numeric x and y parameters for Expr.filter.CHILD
                                    // remember that false/true cast respectively to 0/1
                                    match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
                                    match[5] = +((match[7] + match[8]) || match[3] === "odd");

                                    // other types prohibit arguments
                                } else if (match[3]) {
                                    Sizzle.error(match[0]);
                                }

                                return match;
                            },

                            "PSEUDO": function (match) {
                                var excess,
                                    unquoted = !match[6] && match[2];

                                if (matchExpr["CHILD"].test(match[0])) {
                                    return null;
                                }

                                // Accept quoted arguments as-is
                                if (match[3]) {
                                    match[2] = match[4] || match[5] || "";

                                    // Strip excess characters from unquoted arguments
                                } else if (unquoted && rpseudo.test(unquoted) &&
                                    // Get excess from tokenize (recursively)
                                    (excess = tokenize(unquoted, true)) &&
                                    // advance to the next closing parenthesis
                                    (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {

                                    // excess is a negative index
                                    match[0] = match[0].slice(0, excess);
                                    match[2] = unquoted.slice(0, excess);
                                }

                                // Return only captures needed by the pseudo filter method (type and argument)
                                return match.slice(0, 3);
                            }
                        },

                        filter: {

                            "TAG": function (nodeNameSelector) {
                                var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
                                return nodeNameSelector === "*" ?
                                    function () { return true; } :
                                    function (elem) {
                                        return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
                                    };
                            },

                            "CLASS": function (className) {
                                var pattern = classCache[className + " "];

                                return pattern ||
                                    (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) &&
                                    classCache(className, function (elem) {
                                        return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
                                    });
                            },

                            "ATTR": function (name, operator, check) {
                                return function (elem) {
                                    var result = Sizzle.attr(elem, name);

                                    if (result == null) {
                                        return operator === "!=";
                                    }
                                    if (!operator) {
                                        return true;
                                    }

                                    result += "";

                                    return operator === "=" ? result === check :
                                        operator === "!=" ? result !== check :
                                            operator === "^=" ? check && result.indexOf(check) === 0 :
                                                operator === "*=" ? check && result.indexOf(check) > -1 :
                                                    operator === "$=" ? check && result.slice(-check.length) === check :
                                                        operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 :
                                                            operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" :
                                                                false;
                                };
                            },

                            "CHILD": function (type, what, argument, first, last) {
                                var simple = type.slice(0, 3) !== "nth",
                                    forward = type.slice(-4) !== "last",
                                    ofType = what === "of-type";

                                return first === 1 && last === 0 ?

                                    // Shortcut for :nth-*(n)
                                    function (elem) {
                                        return !!elem.parentNode;
                                    } :

                                    function (elem, context, xml) {
                                        var cache, uniqueCache, outerCache, node, nodeIndex, start,
                                            dir = simple !== forward ? "nextSibling" : "previousSibling",
                                            parent = elem.parentNode,
                                            name = ofType && elem.nodeName.toLowerCase(),
                                            useCache = !xml && !ofType,
                                            diff = false;

                                        if (parent) {

                                            // :(first|last|only)-(child|of-type)
                                            if (simple) {
                                                while (dir) {
                                                    node = elem;
                                                    while ((node = node[dir])) {
                                                        if (ofType ?
                                                            node.nodeName.toLowerCase() === name :
                                                            node.nodeType === 1) {

                                                            return false;
                                                        }
                                                    }
                                                    // Reverse direction for :only-* (if we haven't yet done so)
                                                    start = dir = type === "only" && !start && "nextSibling";
                                                }
                                                return true;
                                            }

                                            start = [forward ? parent.firstChild : parent.lastChild];

                                            // non-xml :nth-child(...) stores cache data on `parent`
                                            if (forward && useCache) {

                                                // Seek `elem` from a previously-cached index

                                                // ...in a gzip-friendly way
                                                node = parent;
                                                outerCache = node[expando] || (node[expando] = {});

                                                // Support: IE <9 only
                                                // Defend against cloned attroperties (jQuery gh-1709)
                                                uniqueCache = outerCache[node.uniqueID] ||
                                                    (outerCache[node.uniqueID] = {});

                                                cache = uniqueCache[type] || [];
                                                nodeIndex = cache[0] === dirruns && cache[1];
                                                diff = nodeIndex && cache[2];
                                                node = nodeIndex && parent.childNodes[nodeIndex];

                                                while ((node = ++nodeIndex && node && node[dir] ||

                                                    // Fallback to seeking `elem` from the start
                                                    (diff = nodeIndex = 0) || start.pop())) {

                                                    // When found, cache indexes on `parent` and break
                                                    if (node.nodeType === 1 && ++diff && node === elem) {
                                                        uniqueCache[type] = [dirruns, nodeIndex, diff];
                                                        break;
                                                    }
                                                }

                                            } else {
                                                // Use previously-cached element index if available
                                                if (useCache) {
                                                    // ...in a gzip-friendly way
                                                    node = elem;
                                                    outerCache = node[expando] || (node[expando] = {});

                                                    // Support: IE <9 only
                                                    // Defend against cloned attroperties (jQuery gh-1709)
                                                    uniqueCache = outerCache[node.uniqueID] ||
                                                        (outerCache[node.uniqueID] = {});

                                                    cache = uniqueCache[type] || [];
                                                    nodeIndex = cache[0] === dirruns && cache[1];
                                                    diff = nodeIndex;
                                                }

                                                // xml :nth-child(...)
                                                // or :nth-last-child(...) or :nth(-last)?-of-type(...)
                                                if (diff === false) {
                                                    // Use the same loop as above to seek `elem` from the start
                                                    while ((node = ++nodeIndex && node && node[dir] ||
                                                        (diff = nodeIndex = 0) || start.pop())) {

                                                        if ((ofType ?
                                                            node.nodeName.toLowerCase() === name :
                                                            node.nodeType === 1) &&
                                                            ++diff) {

                                                            // Cache the index of each encountered element
                                                            if (useCache) {
                                                                outerCache = node[expando] || (node[expando] = {});

                                                                // Support: IE <9 only
                                                                // Defend against cloned attroperties (jQuery gh-1709)
                                                                uniqueCache = outerCache[node.uniqueID] ||
                                                                    (outerCache[node.uniqueID] = {});

                                                                uniqueCache[type] = [dirruns, diff];
                                                            }

                                                            if (node === elem) {
                                                                break;
                                                            }
                                                        }
                                                    }
                                                }
                                            }

                                            // Incorporate the offset, then check against cycle size
                                            diff -= last;
                                            return diff === first || (diff % first === 0 && diff / first >= 0);
                                        }
                                    };
                            },

                            "PSEUDO": function (pseudo, argument) {
                                // pseudo-class names are case-insensitive
                                // http://www.w3.org/TR/selectors/#pseudo-classes
                                // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
                                // Remember that setFilters inherits from pseudos
                                var args,
                                    fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] ||
                                        Sizzle.error("unsupported pseudo: " + pseudo);

                                // The user may use createPseudo to indicate that
                                // arguments are needed to create the filter function
                                // just as Sizzle does
                                if (fn[expando]) {
                                    return fn(argument);
                                }

                                // But maintain support for old signatures
                                if (fn.length > 1) {
                                    args = [pseudo, pseudo, "", argument];
                                    return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ?
                                        markFunction(function (seed, matches) {
                                            var idx,
                                                matched = fn(seed, argument),
                                                i = matched.length;
                                            while (i--) {
                                                idx = indexOf(seed, matched[i]);
                                                seed[idx] = !(matches[idx] = matched[i]);
                                            }
                                        }) :
                                        function (elem) {
                                            return fn(elem, 0, args);
                                        };
                                }

                                return fn;
                            }
                        },

                        pseudos: {
                            // Potentially complex pseudos
                            "not": markFunction(function (selector) {
                                // Trim the selector passed to compile
                                // to avoid treating leading and trailing
                                // spaces as combinators
                                var input = [],
                                    results = [],
                                    matcher = compile(selector.replace(rtrim, "$1"));

                                return matcher[expando] ?
                                    markFunction(function (seed, matches, context, xml) {
                                        var elem,
                                            unmatched = matcher(seed, null, xml, []),
                                            i = seed.length;

                                        // Match elements unmatched by `matcher`
                                        while (i--) {
                                            if ((elem = unmatched[i])) {
                                                seed[i] = !(matches[i] = elem);
                                            }
                                        }
                                    }) :
                                    function (elem, context, xml) {
                                        input[0] = elem;
                                        matcher(input, null, xml, results);
                                        // Don't keep the element (issue #299)
                                        input[0] = null;
                                        return !results.pop();
                                    };
                            }),

                            "has": markFunction(function (selector) {
                                return function (elem) {
                                    return Sizzle(selector, elem).length > 0;
                                };
                            }),

                            "contains": markFunction(function (text) {
                                text = text.replace(runescape, funescape);
                                return function (elem) {
                                    return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
                                };
                            }),

                            // "Whether an element is represented by a :lang() selector
                            // is based solely on the element's language value
                            // being equal to the identifier C,
                            // or beginning with the identifier C immediately followed by "-".
                            // The matching of C against the element's language value is performed case-insensitively.
                            // The identifier C does not have to be a valid language name."
                            // http://www.w3.org/TR/selectors/#lang-pseudo
                            "lang": markFunction(function (lang) {
                                // lang value must be a valid identifier
                                if (!ridentifier.test(lang || "")) {
                                    Sizzle.error("unsupported lang: " + lang);
                                }
                                lang = lang.replace(runescape, funescape).toLowerCase();
                                return function (elem) {
                                    var elemLang;
                                    do {
                                        if ((elemLang = documentIsHTML ?
                                            elem.lang :
                                            elem.getAttribute("xml:lang") || elem.getAttribute("lang"))) {

                                            elemLang = elemLang.toLowerCase();
                                            return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
                                        }
                                    } while ((elem = elem.parentNode) && elem.nodeType === 1);
                                    return false;
                                };
                            }),

                            // Miscellaneous
                            "target": function (elem) {
                                var hash = window.location && window.location.hash;
                                return hash && hash.slice(1) === elem.id;
                            },

                            "root": function (elem) {
                                return elem === docElem;
                            },

                            "focus": function (elem) {
                                return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
                            },

                            // Boolean properties
                            "enabled": createDisabledPseudo(false),
                            "disabled": createDisabledPseudo(true),

                            "checked": function (elem) {
                                // In CSS3, :checked should return both checked and selected elements
                                // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
                                var nodeName = elem.nodeName.toLowerCase();
                                return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
                            },

                            "selected": function (elem) {
                                // Accessing this property makes selected-by-default
                                // options in Safari work properly
                                if (elem.parentNode) {
                                    elem.parentNode.selectedIndex;
                                }

                                return elem.selected === true;
                            },

                            // Contents
                            "empty": function (elem) {
                                // http://www.w3.org/TR/selectors/#empty-pseudo
                                // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
                                //   but not by others (comment: 8; processing instruction: 7; etc.)
                                // nodeType < 6 works because attributes (2) do not appear as children
                                for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
                                    if (elem.nodeType < 6) {
                                        return false;
                                    }
                                }
                                return true;
                            },

                            "parent": function (elem) {
                                return !Expr.pseudos["empty"](elem);
                            },

                            // Element/input types
                            "header": function (elem) {
                                return rheader.test(elem.nodeName);
                            },

                            "input": function (elem) {
                                return rinputs.test(elem.nodeName);
                            },

                            "button": function (elem) {
                                var name = elem.nodeName.toLowerCase();
                                return name === "input" && elem.type === "button" || name === "button";
                            },

                            "text": function (elem) {
                                var attr;
                                return elem.nodeName.toLowerCase() === "input" &&
                                    elem.type === "text" &&

                                    // Support: IE<8
                                    // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
                                    ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
                            },

                            // Position-in-collection
                            "first": createPositionalPseudo(function () {
                                return [0];
                            }),

                            "last": createPositionalPseudo(function (matchIndexes, length) {
                                return [length - 1];
                            }),

                            "eq": createPositionalPseudo(function (matchIndexes, length, argument) {
                                return [argument < 0 ? argument + length : argument];
                            }),

                            "even": createPositionalPseudo(function (matchIndexes, length) {
                                var i = 0;
                                for (; i < length; i += 2) {
                                    matchIndexes.push(i);
                                }
                                return matchIndexes;
                            }),

                            "odd": createPositionalPseudo(function (matchIndexes, length) {
                                var i = 1;
                                for (; i < length; i += 2) {
                                    matchIndexes.push(i);
                                }
                                return matchIndexes;
                            }),

                            "lt": createPositionalPseudo(function (matchIndexes, length, argument) {
                                var i = argument < 0 ? argument + length : argument;
                                for (; --i >= 0;) {
                                    matchIndexes.push(i);
                                }
                                return matchIndexes;
                            }),

                            "gt": createPositionalPseudo(function (matchIndexes, length, argument) {
                                var i = argument < 0 ? argument + length : argument;
                                for (; ++i < length;) {
                                    matchIndexes.push(i);
                                }
                                return matchIndexes;
                            })
                        }
                    };

                    Expr.pseudos["nth"] = Expr.pseudos["eq"];

                    // Add button/input type pseudos
                    for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {
                        Expr.pseudos[i] = createInputPseudo(i);
                    }
                    for (i in { submit: true, reset: true }) {
                        Expr.pseudos[i] = createButtonPseudo(i);
                    }

                    // Easy API for creating new setFilters
                    function setFilters() { }
                    setFilters.prototype = Expr.filters = Expr.pseudos;
                    Expr.setFilters = new setFilters();

                    tokenize = Sizzle.tokenize = function (selector, parseOnly) {
                        var matched, match, tokens, type,
                            soFar, groups, preFilters,
                            cached = tokenCache[selector + " "];

                        if (cached) {
                            return parseOnly ? 0 : cached.slice(0);
                        }

                        soFar = selector;
                        groups = [];
                        preFilters = Expr.preFilter;

                        while (soFar) {

                            // Comma and first run
                            if (!matched || (match = rcomma.exec(soFar))) {
                                if (match) {
                                    // Don't consume trailing commas as valid
                                    soFar = soFar.slice(match[0].length) || soFar;
                                }
                                groups.push((tokens = []));
                            }

                            matched = false;

                            // Combinators
                            if ((match = rcombinators.exec(soFar))) {
                                matched = match.shift();
                                tokens.push({
                                    value: matched,
                                    // Cast descendant combinators to space
                                    type: match[0].replace(rtrim, " ")
                                });
                                soFar = soFar.slice(matched.length);
                            }

                            // Filters
                            for (type in Expr.filter) {
                                if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] ||
                                    (match = preFilters[type](match)))) {
                                    matched = match.shift();
                                    tokens.push({
                                        value: matched,
                                        type: type,
                                        matches: match
                                    });
                                    soFar = soFar.slice(matched.length);
                                }
                            }

                            if (!matched) {
                                break;
                            }
                        }

                        // Return the length of the invalid excess
                        // if we're just parsing
                        // Otherwise, throw an error or return tokens
                        return parseOnly ?
                            soFar.length :
                            soFar ?
                                Sizzle.error(selector) :
                                // Cache the tokens
                                tokenCache(selector, groups).slice(0);
                    };

                    function toSelector(tokens) {
                        var i = 0,
                            len = tokens.length,
                            selector = "";
                        for (; i < len; i++) {
                            selector += tokens[i].value;
                        }
                        return selector;
                    }

                    function addCombinator(matcher, combinator, base) {
                        var dir = combinator.dir,
                            skip = combinator.next,
                            key = skip || dir,
                            checkNonElements = base && key === "parentNode",
                            doneName = done++;

                        return combinator.first ?
                            // Check against closest ancestor/preceding element
                            function (elem, context, xml) {
                                while ((elem = elem[dir])) {
                                    if (elem.nodeType === 1 || checkNonElements) {
                                        return matcher(elem, context, xml);
                                    }
                                }
                                return false;
                            } :

                            // Check against all ancestor/preceding elements
                            function (elem, context, xml) {
                                var oldCache, uniqueCache, outerCache,
                                    newCache = [dirruns, doneName];

                                // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
                                if (xml) {
                                    while ((elem = elem[dir])) {
                                        if (elem.nodeType === 1 || checkNonElements) {
                                            if (matcher(elem, context, xml)) {
                                                return true;
                                            }
                                        }
                                    }
                                } else {
                                    while ((elem = elem[dir])) {
                                        if (elem.nodeType === 1 || checkNonElements) {
                                            outerCache = elem[expando] || (elem[expando] = {});

                                            // Support: IE <9 only
                                            // Defend against cloned attroperties (jQuery gh-1709)
                                            uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});

                                            if (skip && skip === elem.nodeName.toLowerCase()) {
                                                elem = elem[dir] || elem;
                                            } else if ((oldCache = uniqueCache[key]) &&
                                                oldCache[0] === dirruns && oldCache[1] === doneName) {

                                                // Assign to newCache so results back-propagate to previous elements
                                                return (newCache[2] = oldCache[2]);
                                            } else {
                                                // Reuse newcache so results back-propagate to previous elements
                                                uniqueCache[key] = newCache;

                                                // A match means we're done; a fail means we have to keep checking
                                                if ((newCache[2] = matcher(elem, context, xml))) {
                                                    return true;
                                                }
                                            }
                                        }
                                    }
                                }
                                return false;
                            };
                    }

                    function elementMatcher(matchers) {
                        return matchers.length > 1 ?
                            function (elem, context, xml) {
                                var i = matchers.length;
                                while (i--) {
                                    if (!matchers[i](elem, context, xml)) {
                                        return false;
                                    }
                                }
                                return true;
                            } :
                            matchers[0];
                    }

                    function multipleContexts(selector, contexts, results) {
                        var i = 0,
                            len = contexts.length;
                        for (; i < len; i++) {
                            Sizzle(selector, contexts[i], results);
                        }
                        return results;
                    }

                    function condense(unmatched, map, filter, context, xml) {
                        var elem,
                            newUnmatched = [],
                            i = 0,
                            len = unmatched.length,
                            mapped = map != null;

                        for (; i < len; i++) {
                            if ((elem = unmatched[i])) {
                                if (!filter || filter(elem, context, xml)) {
                                    newUnmatched.push(elem);
                                    if (mapped) {
                                        map.push(i);
                                    }
                                }
                            }
                        }

                        return newUnmatched;
                    }

                    function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
                        if (postFilter && !postFilter[expando]) {
                            postFilter = setMatcher(postFilter);
                        }
                        if (postFinder && !postFinder[expando]) {
                            postFinder = setMatcher(postFinder, postSelector);
                        }
                        return markFunction(function (seed, results, context, xml) {
                            var temp, i, elem,
                                preMap = [],
                                postMap = [],
                                preexisting = results.length,

                                // Get initial elements from seed or context
                                elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),

                                // Prefilter to get matcher input, preserving a map for seed-results synchronization
                                matcherIn = preFilter && (seed || !selector) ?
                                    condense(elems, preMap, preFilter, context, xml) :
                                    elems,

                                matcherOut = matcher ?
                                    // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
                                    postFinder || (seed ? preFilter : preexisting || postFilter) ?

                                        // ...intermediate processing is necessary
                                        [] :

                                        // ...otherwise use results directly
                                        results :
                                    matcherIn;

                            // Find primary matches
                            if (matcher) {
                                matcher(matcherIn, matcherOut, context, xml);
                            }

                            // Apply postFilter
                            if (postFilter) {
                                temp = condense(matcherOut, postMap);
                                postFilter(temp, [], context, xml);

                                // Un-match failing elements by moving them back to matcherIn
                                i = temp.length;
                                while (i--) {
                                    if ((elem = temp[i])) {
                                        matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
                                    }
                                }
                            }

                            if (seed) {
                                if (postFinder || preFilter) {
                                    if (postFinder) {
                                        // Get the final matcherOut by condensing this intermediate into postFinder contexts
                                        temp = [];
                                        i = matcherOut.length;
                                        while (i--) {
                                            if ((elem = matcherOut[i])) {
                                                // Restore matcherIn since elem is not yet a final match
                                                temp.push((matcherIn[i] = elem));
                                            }
                                        }
                                        postFinder(null, (matcherOut = []), temp, xml);
                                    }

                                    // Move matched elements from seed to results to keep them synchronized
                                    i = matcherOut.length;
                                    while (i--) {
                                        if ((elem = matcherOut[i]) &&
                                            (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {

                                            seed[temp] = !(results[temp] = elem);
                                        }
                                    }
                                }

                                // Add elements to results, through postFinder if defined
                            } else {
                                matcherOut = condense(
                                    matcherOut === results ?
                                        matcherOut.splice(preexisting, matcherOut.length) :
                                        matcherOut
                                );
                                if (postFinder) {
                                    postFinder(null, results, matcherOut, xml);
                                } else {
                                    push.apply(results, matcherOut);
                                }
                            }
                        });
                    }

                    function matcherFromTokens(tokens) {
                        var checkContext, matcher, j,
                            len = tokens.length,
                            leadingRelative = Expr.relative[tokens[0].type],
                            implicitRelative = leadingRelative || Expr.relative[" "],
                            i = leadingRelative ? 1 : 0,

                            // The foundational matcher ensures that elements are reachable from top-level context(s)
                            matchContext = addCombinator(function (elem) {
                                return elem === checkContext;
                            }, implicitRelative, true),
                            matchAnyContext = addCombinator(function (elem) {
                                return indexOf(checkContext, elem) > -1;
                            }, implicitRelative, true),
                            matchers = [function (elem, context, xml) {
                                var ret = (!leadingRelative && (xml || context !== outermostContext)) || (
                                    (checkContext = context).nodeType ?
                                        matchContext(elem, context, xml) :
                                        matchAnyContext(elem, context, xml));
                                // Avoid hanging onto element (issue #299)
                                checkContext = null;
                                return ret;
                            }];

                        for (; i < len; i++) {
                            if ((matcher = Expr.relative[tokens[i].type])) {
                                matchers = [addCombinator(elementMatcher(matchers), matcher)];
                            } else {
                                matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);

                                // Return special upon seeing a positional matcher
                                if (matcher[expando]) {
                                    // Find the next relative operator (if any) for proper handling
                                    j = ++i;
                                    for (; j < len; j++) {
                                        if (Expr.relative[tokens[j].type]) {
                                            break;
                                        }
                                    }
                                    return setMatcher(
                                        i > 1 && elementMatcher(matchers),
                                        i > 1 && toSelector(
                                            // If the preceding token was a descendant combinator, insert an implicit any-element `*`
                                            tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })
                                        ).replace(rtrim, "$1"),
                                        matcher,
                                        i < j && matcherFromTokens(tokens.slice(i, j)),
                                        j < len && matcherFromTokens((tokens = tokens.slice(j))),
                                        j < len && toSelector(tokens)
                                    );
                                }
                                matchers.push(matcher);
                            }
                        }

                        return elementMatcher(matchers);
                    }

                    function matcherFromGroupMatchers(elementMatchers, setMatchers) {
                        var bySet = setMatchers.length > 0,
                            byElement = elementMatchers.length > 0,
                            superMatcher = function (seed, context, xml, results, outermost) {
                                var elem, j, matcher,
                                    matchedCount = 0,
                                    i = "0",
                                    unmatched = seed && [],
                                    setMatched = [],
                                    contextBackup = outermostContext,
                                    // We must always have either seed elements or outermost context
                                    elems = seed || byElement && Expr.find["TAG"]("*", outermost),
                                    // Use integer dirruns iff this is the outermost matcher
                                    dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
                                    len = elems.length;

                                if (outermost) {
                                    outermostContext = context === document || context || outermost;
                                }

                                // Add elements passing elementMatchers directly to results
                                // Support: IE<9, Safari
                                // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
                                for (; i !== len && (elem = elems[i]) != null; i++) {
                                    if (byElement && elem) {
                                        j = 0;
                                        if (!context && elem.ownerDocument !== document) {
                                            setDocument(elem);
                                            xml = !documentIsHTML;
                                        }
                                        while ((matcher = elementMatchers[j++])) {
                                            if (matcher(elem, context || document, xml)) {
                                                results.push(elem);
                                                break;
                                            }
                                        }
                                        if (outermost) {
                                            dirruns = dirrunsUnique;
                                        }
                                    }

                                    // Track unmatched elements for set filters
                                    if (bySet) {
                                        // They will have gone through all possible matchers
                                        if ((elem = !matcher && elem)) {
                                            matchedCount--;
                                        }

                                        // Lengthen the array for every element, matched or not
                                        if (seed) {
                                            unmatched.push(elem);
                                        }
                                    }
                                }

                                // `i` is now the count of elements visited above, and adding it to `matchedCount`
                                // makes the latter nonnegative.
                                matchedCount += i;

                                // Apply set filters to unmatched elements
                                // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
                                // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
                                // no element matchers and no seed.
                                // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
                                // case, which will result in a "00" `matchedCount` that differs from `i` but is also
                                // numerically zero.
                                if (bySet && i !== matchedCount) {
                                    j = 0;
                                    while ((matcher = setMatchers[j++])) {
                                        matcher(unmatched, setMatched, context, xml);
                                    }

                                    if (seed) {
                                        // Reintegrate element matches to eliminate the need for sorting
                                        if (matchedCount > 0) {
                                            while (i--) {
                                                if (!(unmatched[i] || setMatched[i])) {
                                                    setMatched[i] = pop.call(results);
                                                }
                                            }
                                        }

                                        // Discard index placeholder values to get only actual matches
                                        setMatched = condense(setMatched);
                                    }

                                    // Add matches to results
                                    push.apply(results, setMatched);

                                    // Seedless set matches succeeding multiple successful matchers stipulate sorting
                                    if (outermost && !seed && setMatched.length > 0 &&
                                        (matchedCount + setMatchers.length) > 1) {

                                        Sizzle.uniqueSort(results);
                                    }
                                }

                                // Override manipulation of globals by nested matchers
                                if (outermost) {
                                    dirruns = dirrunsUnique;
                                    outermostContext = contextBackup;
                                }

                                return unmatched;
                            };

                        return bySet ?
                            markFunction(superMatcher) :
                            superMatcher;
                    }

                    compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {
                        var i,
                            setMatchers = [],
                            elementMatchers = [],
                            cached = compilerCache[selector + " "];

                        if (!cached) {
                            // Generate a function of recursive functions that can be used to check each element
                            if (!match) {
                                match = tokenize(selector);
                            }
                            i = match.length;
                            while (i--) {
                                cached = matcherFromTokens(match[i]);
                                if (cached[expando]) {
                                    setMatchers.push(cached);
                                } else {
                                    elementMatchers.push(cached);
                                }
                            }

                            // Cache the compiled function
                            cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));

                            // Save selector and tokenization
                            cached.selector = selector;
                        }
                        return cached;
                    };

                    /**
                     * A low-level selection function that works with Sizzle's compiled
                     *  selector functions
                     * @param {String|Function} selector A selector or a pre-compiled
                     *  selector function built with Sizzle.compile
                     * @param {Element} context
                     * @param {Array} [results]
                     * @param {Array} [seed] A set of elements to match against
                     */
                    select = Sizzle.select = function (selector, context, results, seed) {
                        var i, tokens, token, type, find,
                            compiled = typeof selector === "function" && selector,
                            match = !seed && tokenize((selector = compiled.selector || selector));

                        results = results || [];

                        // Try to minimize operations if there is only one selector in the list and no seed
                        // (the latter of which guarantees us context)
                        if (match.length === 1) {

                            // Reduce context if the leading compound selector is an ID
                            tokens = match[0] = match[0].slice(0);
                            if (tokens.length > 2 && (token = tokens[0]).type === "ID" &&
                                context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {

                                context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
                                if (!context) {
                                    return results;

                                    // Precompiled matchers will still verify ancestry, so step up a level
                                } else if (compiled) {
                                    context = context.parentNode;
                                }

                                selector = selector.slice(tokens.shift().value.length);
                            }

                            // Fetch a seed set for right-to-left matching
                            i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
                            while (i--) {
                                token = tokens[i];

                                // Abort if we hit a combinator
                                if (Expr.relative[(type = token.type)]) {
                                    break;
                                }
                                if ((find = Expr.find[type])) {
                                    // Search, expanding context for leading sibling combinators
                                    if ((seed = find(
                                        token.matches[0].replace(runescape, funescape),
                                        rsibling.test(tokens[0].type) && testContext(context.parentNode) || context
                                    ))) {

                                        // If seed is empty or no tokens remain, we can return early
                                        tokens.splice(i, 1);
                                        selector = seed.length && toSelector(tokens);
                                        if (!selector) {
                                            push.apply(results, seed);
                                            return results;
                                        }

                                        break;
                                    }
                                }
                            }
                        }

                        // Compile and execute a filtering function if one is not provided
                        // Provide `match` to avoid retokenization if we modified the selector above
                        (compiled || compile(selector, match))(
                            seed,
                            context,
                            !documentIsHTML,
                            results,
                            !context || rsibling.test(selector) && testContext(context.parentNode) || context
                        );
                        return results;
                    };

                    // One-time assignments

                    // Sort stability
                    support.sortStable = expando.split("").sort(sortOrder).join("") === expando;

                    // Support: Chrome 14-35+
                    // Always assume duplicates if they aren't passed to the comparison function
                    support.detectDuplicates = !!hasDuplicate;

                    // Initialize against the default document
                    setDocument();

                    // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
                    // Detached nodes confoundingly follow *each other*
                    support.sortDetached = assert(function (el) {
                        // Should return 1, but returns 4 (following)
                        return el.compareDocumentPosition(document.createElement("fieldset")) & 1;
                    });

                    // Support: IE<8
                    // Prevent attribute/property "interpolation"
                    // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
                    if (!assert(function (el) {
                        el.innerHTML = "<a href='#'></a>";
                        return el.firstChild.getAttribute("href") === "#";
                    })) {
                        addHandle("type|href|height|width", function (elem, name, isXML) {
                            if (!isXML) {
                                return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
                            }
                        });
                    }

                    // Support: IE<9
                    // Use defaultValue in place of getAttribute("value")
                    if (!support.attributes || !assert(function (el) {
                        el.innerHTML = "<input/>";
                        el.firstChild.setAttribute("value", "");
                        return el.firstChild.getAttribute("value") === "";
                    })) {
                        addHandle("value", function (elem, name, isXML) {
                            if (!isXML && elem.nodeName.toLowerCase() === "input") {
                                return elem.defaultValue;
                            }
                        });
                    }

                    // Support: IE<9
                    // Use getAttributeNode to fetch booleans when getAttribute lies
                    if (!assert(function (el) {
                        return el.getAttribute("disabled") == null;
                    })) {
                        addHandle(booleans, function (elem, name, isXML) {
                            var val;
                            if (!isXML) {
                                return elem[name] === true ? name.toLowerCase() :
                                    (val = elem.getAttributeNode(name)) && val.specified ?
                                        val.value :
                                        null;
                            }
                        });
                    }

                    return Sizzle;

                })(window);



            jQuery.find = Sizzle;
            jQuery.expr = Sizzle.selectors;

            // Deprecated
            jQuery.expr[":"] = jQuery.expr.pseudos;
            jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
            jQuery.text = Sizzle.getText;
            jQuery.isXMLDoc = Sizzle.isXML;
            jQuery.contains = Sizzle.contains;
            jQuery.escapeSelector = Sizzle.escape;




            var dir = function (elem, dir, until) {
                var matched = [],
                    truncate = until !== undefined;

                while ((elem = elem[dir]) && elem.nodeType !== 9) {
                    if (elem.nodeType === 1) {
                        if (truncate && jQuery(elem).is(until)) {
                            break;
                        }
                        matched.push(elem);
                    }
                }
                return matched;
            };


            var siblings = function (n, elem) {
                var matched = [];

                for (; n; n = n.nextSibling) {
                    if (n.nodeType === 1 && n !== elem) {
                        matched.push(n);
                    }
                }

                return matched;
            };


            var rneedsContext = jQuery.expr.match.needsContext;



            function nodeName(elem, name) {

                return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();

            };
            var rsingleTag = (/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i);



            var risSimple = /^.[^:#\[\.,]*$/;

            // Implement the identical functionality for filter and not
            function winnow(elements, qualifier, not) {
                if (jQuery.isFunction(qualifier)) {
                    return jQuery.grep(elements, function (elem, i) {
                        return !!qualifier.call(elem, i, elem) !== not;
                    });
                }

                // Single element
                if (qualifier.nodeType) {
                    return jQuery.grep(elements, function (elem) {
                        return (elem === qualifier) !== not;
                    });
                }

                // Arraylike of elements (jQuery, arguments, Array)
                if (typeof qualifier !== "string") {
                    return jQuery.grep(elements, function (elem) {
                        return (indexOf.call(qualifier, elem) > -1) !== not;
                    });
                }

                // Simple selector that can be filtered directly, removing non-Elements
                if (risSimple.test(qualifier)) {
                    return jQuery.filter(qualifier, elements, not);
                }

                // Complex selector, compare the two sets, removing non-Elements
                qualifier = jQuery.filter(qualifier, elements);
                return jQuery.grep(elements, function (elem) {
                    return (indexOf.call(qualifier, elem) > -1) !== not && elem.nodeType === 1;
                });
            }

            jQuery.filter = function (expr, elems, not) {
                var elem = elems[0];

                if (not) {
                    expr = ":not(" + expr + ")";
                }

                if (elems.length === 1 && elem.nodeType === 1) {
                    return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];
                }

                return jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
                    return elem.nodeType === 1;
                }));
            };

            jQuery.fn.extend({
                find: function (selector) {
                    var i, ret,
                        len = this.length,
                        self = this;

                    if (typeof selector !== "string") {
                        return this.pushStack(jQuery(selector).filter(function () {
                            for (i = 0; i < len; i++) {
                                if (jQuery.contains(self[i], this)) {
                                    return true;
                                }
                            }
                        }));
                    }

                    ret = this.pushStack([]);

                    for (i = 0; i < len; i++) {
                        jQuery.find(selector, self[i], ret);
                    }

                    return len > 1 ? jQuery.uniqueSort(ret) : ret;
                },
                filter: function (selector) {
                    return this.pushStack(winnow(this, selector || [], false));
                },
                not: function (selector) {
                    return this.pushStack(winnow(this, selector || [], true));
                },
                is: function (selector) {
                    return !!winnow(
                        this,

                        // If this is a positional/relative selector, check membership in the returned set
                        // so $("p:first").is("p:last") won't return true for a doc with two "p".
                        typeof selector === "string" && rneedsContext.test(selector) ?
                            jQuery(selector) :
                            selector || [],
                        false
                    ).length;
                }
            });


            // Initialize a jQuery object


            // A central reference to the root jQuery(document)
            var rootjQuery,

                // A simple way to check for HTML strings
                // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
                // Strict HTML recognition (#11290: must start with <)
                // Shortcut simple #id case for speed
                rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,

                init = jQuery.fn.init = function (selector, context, root) {
                    var match, elem;

                    // HANDLE: $(""), $(null), $(undefined), $(false)
                    if (!selector) {
                        return this;
                    }

                    // Method init() accepts an alternate rootjQuery
                    // so migrate can support jQuery.sub (gh-2101)
                    root = root || rootjQuery;

                    // Handle HTML strings
                    if (typeof selector === "string") {
                        if (selector[0] === "<" &&
                            selector[selector.length - 1] === ">" &&
                            selector.length >= 3) {

                            // Assume that strings that start and end with <> are HTML and skip the regex check
                            match = [null, selector, null];

                        } else {
                            match = rquickExpr.exec(selector);
                        }

                        // Match html or make sure no context is specified for #id
                        if (match && (match[1] || !context)) {

                            // HANDLE: $(html) -> $(array)
                            if (match[1]) {
                                context = context instanceof jQuery ? context[0] : context;

                                // Option to run scripts is true for back-compat
                                // Intentionally let the error be thrown if parseHTML is not present
                                jQuery.merge(this, jQuery.parseHTML(
                                    match[1],
                                    context && context.nodeType ? context.ownerDocument || context : document,
                                    true
                                ));

                                // HANDLE: $(html, props)
                                if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
                                    for (match in context) {

                                        // Properties of context are called as methods if possible
                                        if (jQuery.isFunction(this[match])) {
                                            this[match](context[match]);

                                            // ...and otherwise set as attributes
                                        } else {
                                            this.attr(match, context[match]);
                                        }
                                    }
                                }

                                return this;

                                // HANDLE: $(#id)
                            } else {
                                elem = document.getElementById(match[2]);

                                if (elem) {

                                    // Inject the element directly into the jQuery object
                                    this[0] = elem;
                                    this.length = 1;
                                }
                                return this;
                            }

                            // HANDLE: $(expr, $(...))
                        } else if (!context || context.jquery) {
                            return (context || root).find(selector);

                            // HANDLE: $(expr, context)
                            // (which is just equivalent to: $(context).find(expr)
                        } else {
                            return this.constructor(context).find(selector);
                        }

                        // HANDLE: $(DOMElement)
                    } else if (selector.nodeType) {
                        this[0] = selector;
                        this.length = 1;
                        return this;

                        // HANDLE: $(function)
                        // Shortcut for document ready
                    } else if (jQuery.isFunction(selector)) {
                        return root.ready !== undefined ?
                            root.ready(selector) :

                            // Execute immediately if ready is not present
                            selector(jQuery);
                    }

                    return jQuery.makeArray(selector, this);
                };

            // Give the init function the jQuery prototype for later instantiation
            init.prototype = jQuery.fn;

            // Initialize central reference
            rootjQuery = jQuery(document);


            var rparentsprev = /^(?:parents|prev(?:Until|All))/,

                // Methods guaranteed to produce a unique set when starting from a unique set
                guaranteedUnique = {
                    children: true,
                    contents: true,
                    next: true,
                    prev: true
                };

            jQuery.fn.extend({
                has: function (target) {
                    var targets = jQuery(target, this),
                        l = targets.length;

                    return this.filter(function () {
                        var i = 0;
                        for (; i < l; i++) {
                            if (jQuery.contains(this, targets[i])) {
                                return true;
                            }
                        }
                    });
                },

                closest: function (selectors, context) {
                    var cur,
                        i = 0,
                        l = this.length,
                        matched = [],
                        targets = typeof selectors !== "string" && jQuery(selectors);

                    // Positional selectors never match, since there's no _selection_ context
                    if (!rneedsContext.test(selectors)) {
                        for (; i < l; i++) {
                            for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {

                                // Always skip document fragments
                                if (cur.nodeType < 11 && (targets ?
                                    targets.index(cur) > -1 :

                                    // Don't pass non-elements to Sizzle
                                    cur.nodeType === 1 &&
                                    jQuery.find.matchesSelector(cur, selectors))) {

                                    matched.push(cur);
                                    break;
                                }
                            }
                        }
                    }

                    return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);
                },

                // Determine the position of an element within the set
                index: function (elem) {

                    // No argument, return index in parent
                    if (!elem) {
                        return (this[0] && this[0].parentNode) ? this.first().prevAll().length : -1;
                    }

                    // Index in selector
                    if (typeof elem === "string") {
                        return indexOf.call(jQuery(elem), this[0]);
                    }

                    // Locate the position of the desired element
                    return indexOf.call(this,

                        // If it receives a jQuery object, the first element is used
                        elem.jquery ? elem[0] : elem
                    );
                },

                add: function (selector, context) {
                    return this.pushStack(
                        jQuery.uniqueSort(
                            jQuery.merge(this.get(), jQuery(selector, context))
                        )
                    );
                },

                addBack: function (selector) {
                    return this.add(selector == null ?
                        this.prevObject : this.prevObject.filter(selector)
                    );
                }
            });

            function sibling(cur, dir) {
                while ((cur = cur[dir]) && cur.nodeType !== 1) { }
                return cur;
            }

            jQuery.each({
                parent: function (elem) {
                    var parent = elem.parentNode;
                    return parent && parent.nodeType !== 11 ? parent : null;
                },
                parents: function (elem) {
                    return dir(elem, "parentNode");
                },
                parentsUntil: function (elem, i, until) {
                    return dir(elem, "parentNode", until);
                },
                next: function (elem) {
                    return sibling(elem, "nextSibling");
                },
                prev: function (elem) {
                    return sibling(elem, "previousSibling");
                },
                nextAll: function (elem) {
                    return dir(elem, "nextSibling");
                },
                prevAll: function (elem) {
                    return dir(elem, "previousSibling");
                },
                nextUntil: function (elem, i, until) {
                    return dir(elem, "nextSibling", until);
                },
                prevUntil: function (elem, i, until) {
                    return dir(elem, "previousSibling", until);
                },
                siblings: function (elem) {
                    return siblings((elem.parentNode || {}).firstChild, elem);
                },
                children: function (elem) {
                    return siblings(elem.firstChild);
                },
                contents: function (elem) {
                    if (nodeName(elem, "iframe")) {
                        return elem.contentDocument;
                    }

                    // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
                    // Treat the template element as a regular one in browsers that
                    // don't support it.
                    if (nodeName(elem, "template")) {
                        elem = elem.content || elem;
                    }

                    return jQuery.merge([], elem.childNodes);
                }
            }, function (name, fn) {
                jQuery.fn[name] = function (until, selector) {
                    var matched = jQuery.map(this, fn, until);

                    if (name.slice(-5) !== "Until") {
                        selector = until;
                    }

                    if (selector && typeof selector === "string") {
                        matched = jQuery.filter(selector, matched);
                    }

                    if (this.length > 1) {

                        // Remove duplicates
                        if (!guaranteedUnique[name]) {
                            jQuery.uniqueSort(matched);
                        }

                        // Reverse order for parents* and prev-derivatives
                        if (rparentsprev.test(name)) {
                            matched.reverse();
                        }
                    }

                    return this.pushStack(matched);
                };
            });
            var rnothtmlwhite = (/[^\x20\t\r\n\f]+/g);



            // Convert String-formatted options into Object-formatted ones
            function createOptions(options) {
                var object = {};
                jQuery.each(options.match(rnothtmlwhite) || [], function (_, flag) {
                    object[flag] = true;
                });
                return object;
            }

            /*
             * Create a callback list using the following parameters:
             *
             *	options: an optional list of space-separated options that will change how
             *			the callback list behaves or a more traditional option object
             *
             * By default a callback list will act like an event callback list and can be
             * "fired" multiple times.
             *
             * Possible options:
             *
             *	once:			will ensure the callback list can only be fired once (like a Deferred)
             *
             *	memory:			will keep track of previous values and will call any callback added
             *					after the list has been fired right away with the latest "memorized"
             *					values (like a Deferred)
             *
             *	unique:			will ensure a callback can only be added once (no duplicate in the list)
             *
             *	stopOnFalse:	interrupt callings when a callback returns false
             *
             */
            jQuery.Callbacks = function (options) {

                // Convert options from String-formatted to Object-formatted if needed
                // (we check in cache first)
                options = typeof options === "string" ?
                    createOptions(options) :
                    jQuery.extend({}, options);

                var // Flag to know if list is currently firing
                    firing,

                    // Last fire value for non-forgettable lists
                    memory,

                    // Flag to know if list was already fired
                    fired,

                    // Flag to prevent firing
                    locked,

                    // Actual callback list
                    list = [],

                    // Queue of execution data for repeatable lists
                    queue = [],

                    // Index of currently firing callback (modified by add/remove as needed)
                    firingIndex = -1,

                    // Fire callbacks
                    fire = function () {

                        // Enforce single-firing
                        locked = locked || options.once;

                        // Execute callbacks for all pending executions,
                        // respecting firingIndex overrides and runtime changes
                        fired = firing = true;
                        for (; queue.length; firingIndex = -1) {
                            memory = queue.shift();
                            while (++firingIndex < list.length) {

                                // Run callback and check for early termination
                                if (list[firingIndex].apply(memory[0], memory[1]) === false &&
                                    options.stopOnFalse) {

                                    // Jump to end and forget the data so .add doesn't re-fire
                                    firingIndex = list.length;
                                    memory = false;
                                }
                            }
                        }

                        // Forget the data if we're done with it
                        if (!options.memory) {
                            memory = false;
                        }

                        firing = false;

                        // Clean up if we're done firing for good
                        if (locked) {

                            // Keep an empty list if we have data for future add calls
                            if (memory) {
                                list = [];

                                // Otherwise, this object is spent
                            } else {
                                list = "";
                            }
                        }
                    },

                    // Actual Callbacks object
                    self = {

                        // Add a callback or a collection of callbacks to the list
                        add: function () {
                            if (list) {

                                // If we have memory from a past run, we should fire after adding
                                if (memory && !firing) {
                                    firingIndex = list.length - 1;
                                    queue.push(memory);
                                }

                                (function add(args) {
                                    jQuery.each(args, function (_, arg) {
                                        if (jQuery.isFunction(arg)) {
                                            if (!options.unique || !self.has(arg)) {
                                                list.push(arg);
                                            }
                                        } else if (arg && arg.length && jQuery.type(arg) !== "string") {

                                            // Inspect recursively
                                            add(arg);
                                        }
                                    });
                                })(arguments);

                                if (memory && !firing) {
                                    fire();
                                }
                            }
                            return this;
                        },

                        // Remove a callback from the list
                        remove: function () {
                            jQuery.each(arguments, function (_, arg) {
                                var index;
                                while ((index = jQuery.inArray(arg, list, index)) > -1) {
                                    list.splice(index, 1);

                                    // Handle firing indexes
                                    if (index <= firingIndex) {
                                        firingIndex--;
                                    }
                                }
                            });
                            return this;
                        },

                        // Check if a given callback is in the list.
                        // If no argument is given, return whether or not list has callbacks attached.
                        has: function (fn) {
                            return fn ?
                                jQuery.inArray(fn, list) > -1 :
                                list.length > 0;
                        },

                        // Remove all callbacks from the list
                        empty: function () {
                            if (list) {
                                list = [];
                            }
                            return this;
                        },

                        // Disable .fire and .add
                        // Abort any current/pending executions
                        // Clear all callbacks and values
                        disable: function () {
                            locked = queue = [];
                            list = memory = "";
                            return this;
                        },
                        disabled: function () {
                            return !list;
                        },

                        // Disable .fire
                        // Also disable .add unless we have memory (since it would have no effect)
                        // Abort any pending executions
                        lock: function () {
                            locked = queue = [];
                            if (!memory && !firing) {
                                list = memory = "";
                            }
                            return this;
                        },
                        locked: function () {
                            return !!locked;
                        },

                        // Call all callbacks with the given context and arguments
                        fireWith: function (context, args) {
                            if (!locked) {
                                args = args || [];
                                args = [context, args.slice ? args.slice() : args];
                                queue.push(args);
                                if (!firing) {
                                    fire();
                                }
                            }
                            return this;
                        },

                        // Call all the callbacks with the given arguments
                        fire: function () {
                            self.fireWith(this, arguments);
                            return this;
                        },

                        // To know if the callbacks have already been called at least once
                        fired: function () {
                            return !!fired;
                        }
                    };

                return self;
            };


            function Identity(v) {
                return v;
            }
            function Thrower(ex) {
                throw ex;
            }

            function adoptValue(value, resolve, reject, noValue) {
                var method;

                try {

                    // Check for promise aspect first to privilege synchronous behavior
                    if (value && jQuery.isFunction((method = value.promise))) {
                        method.call(value).done(resolve).fail(reject);

                        // Other thenables
                    } else if (value && jQuery.isFunction((method = value.then))) {
                        method.call(value, resolve, reject);

                        // Other non-thenables
                    } else {

                        // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
                        // * false: [ value ].slice( 0 ) => resolve( value )
                        // * true: [ value ].slice( 1 ) => resolve()
                        resolve.apply(undefined, [value].slice(noValue));
                    }

                    // For Promises/A+, convert exceptions into rejections
                    // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
                    // Deferred#then to conditionally suppress rejection.
                } catch (value) {

                    // Support: Android 4.0 only
                    // Strict mode functions invoked without .call/.apply get global-object context
                    reject.apply(undefined, [value]);
                }
            }

            jQuery.extend({

                Deferred: function (func) {
                    var tuples = [

                        // action, add listener, callbacks,
                        // ... .then handlers, argument index, [final state]
                        ["notify", "progress", jQuery.Callbacks("memory"),
                            jQuery.Callbacks("memory"), 2],
                        ["resolve", "done", jQuery.Callbacks("once memory"),
                            jQuery.Callbacks("once memory"), 0, "resolved"],
                        ["reject", "fail", jQuery.Callbacks("once memory"),
                            jQuery.Callbacks("once memory"), 1, "rejected"]
                    ],
                        state = "pending",
                        promise = {
                            state: function () {
                                return state;
                            },
                            always: function () {
                                deferred.done(arguments).fail(arguments);
                                return this;
                            },
                            "catch": function (fn) {
                                return promise.then(null, fn);
                            },

                            // Keep pipe for back-compat
                            pipe: function ( /* fnDone, fnFail, fnProgress */) {
                                var fns = arguments;

                                return jQuery.Deferred(function (newDefer) {
                                    jQuery.each(tuples, function (i, tuple) {

                                        // Map tuples (progress, done, fail) to arguments (done, fail, progress)
                                        var fn = jQuery.isFunction(fns[tuple[4]]) && fns[tuple[4]];

                                        // deferred.progress(function() { bind to newDefer or newDefer.notify })
                                        // deferred.done(function() { bind to newDefer or newDefer.resolve })
                                        // deferred.fail(function() { bind to newDefer or newDefer.reject })
                                        deferred[tuple[1]](function () {
                                            var returned = fn && fn.apply(this, arguments);
                                            if (returned && jQuery.isFunction(returned.promise)) {
                                                returned.promise()
                                                    .progress(newDefer.notify)
                                                    .done(newDefer.resolve)
                                                    .fail(newDefer.reject);
                                            } else {
                                                newDefer[tuple[0] + "With"](
                                                    this,
                                                    fn ? [returned] : arguments
                                                );
                                            }
                                        });
                                    });
                                    fns = null;
                                }).promise();
                            },
                            then: function (onFulfilled, onRejected, onProgress) {
                                var maxDepth = 0;
                                function resolve(depth, deferred, handler, special) {
                                    return function () {
                                        var that = this,
                                            args = arguments,
                                            mightThrow = function () {
                                                var returned, then;

                                                // Support: Promises/A+ section 2.3.3.3.3
                                                // https://promisesaplus.com/#point-59
                                                // Ignore double-resolution attempts
                                                if (depth < maxDepth) {
                                                    return;
                                                }

                                                returned = handler.apply(that, args);

                                                // Support: Promises/A+ section 2.3.1
                                                // https://promisesaplus.com/#point-48
                                                if (returned === deferred.promise()) {
                                                    throw new TypeError("Thenable self-resolution");
                                                }

                                                // Support: Promises/A+ sections 2.3.3.1, 3.5
                                                // https://promisesaplus.com/#point-54
                                                // https://promisesaplus.com/#point-75
                                                // Retrieve `then` only once
                                                then = returned &&

                                                    // Support: Promises/A+ section 2.3.4
                                                    // https://promisesaplus.com/#point-64
                                                    // Only check objects and functions for thenability
                                                    (typeof returned === "object" ||
                                                        typeof returned === "function") &&
                                                    returned.then;

                                                // Handle a returned thenable
                                                if (jQuery.isFunction(then)) {

                                                    // Special processors (notify) just wait for resolution
                                                    if (special) {
                                                        then.call(
                                                            returned,
                                                            resolve(maxDepth, deferred, Identity, special),
                                                            resolve(maxDepth, deferred, Thrower, special)
                                                        );

                                                        // Normal processors (resolve) also hook into progress
                                                    } else {

                                                        // ...and disregard older resolution values
                                                        maxDepth++;

                                                        then.call(
                                                            returned,
                                                            resolve(maxDepth, deferred, Identity, special),
                                                            resolve(maxDepth, deferred, Thrower, special),
                                                            resolve(maxDepth, deferred, Identity,
                                                                deferred.notifyWith)
                                                        );
                                                    }

                                                    // Handle all other returned values
                                                } else {

                                                    // Only substitute handlers pass on context
                                                    // and multiple values (non-spec behavior)
                                                    if (handler !== Identity) {
                                                        that = undefined;
                                                        args = [returned];
                                                    }

                                                    // Process the value(s)
                                                    // Default process is resolve
                                                    (special || deferred.resolveWith)(that, args);
                                                }
                                            },

                                            // Only normal processors (resolve) catch and reject exceptions
                                            process = special ?
                                                mightThrow :
                                                function () {
                                                    try {
                                                        mightThrow();
                                                    } catch (e) {

                                                        if (jQuery.Deferred.exceptionHook) {
                                                            jQuery.Deferred.exceptionHook(e,
                                                                process.stackTrace);
                                                        }

                                                        // Support: Promises/A+ section 2.3.3.3.4.1
                                                        // https://promisesaplus.com/#point-61
                                                        // Ignore post-resolution exceptions
                                                        if (depth + 1 >= maxDepth) {

                                                            // Only substitute handlers pass on context
                                                            // and multiple values (non-spec behavior)
                                                            if (handler !== Thrower) {
                                                                that = undefined;
                                                                args = [e];
                                                            }

                                                            deferred.rejectWith(that, args);
                                                        }
                                                    }
                                                };

                                        // Support: Promises/A+ section 2.3.3.3.1
                                        // https://promisesaplus.com/#point-57
                                        // Re-resolve promises immediately to dodge false rejection from
                                        // subsequent errors
                                        if (depth) {
                                            process();
                                        } else {

                                            // Call an optional hook to record the stack, in case of exception
                                            // since it's otherwise lost when execution goes async
                                            if (jQuery.Deferred.getStackHook) {
                                                process.stackTrace = jQuery.Deferred.getStackHook();
                                            }
                                            window.setTimeout(process);
                                        }
                                    };
                                }

                                return jQuery.Deferred(function (newDefer) {

                                    // progress_handlers.add( ... )
                                    tuples[0][3].add(
                                        resolve(
                                            0,
                                            newDefer,
                                            jQuery.isFunction(onProgress) ?
                                                onProgress :
                                                Identity,
                                            newDefer.notifyWith
                                        )
                                    );

                                    // fulfilled_handlers.add( ... )
                                    tuples[1][3].add(
                                        resolve(
                                            0,
                                            newDefer,
                                            jQuery.isFunction(onFulfilled) ?
                                                onFulfilled :
                                                Identity
                                        )
                                    );

                                    // rejected_handlers.add( ... )
                                    tuples[2][3].add(
                                        resolve(
                                            0,
                                            newDefer,
                                            jQuery.isFunction(onRejected) ?
                                                onRejected :
                                                Thrower
                                        )
                                    );
                                }).promise();
                            },

                            // Get a promise for this deferred
                            // If obj is provided, the promise aspect is added to the object
                            promise: function (obj) {
                                return obj != null ? jQuery.extend(obj, promise) : promise;
                            }
                        },
                        deferred = {};

                    // Add list-specific methods
                    jQuery.each(tuples, function (i, tuple) {
                        var list = tuple[2],
                            stateString = tuple[5];

                        // promise.progress = list.add
                        // promise.done = list.add
                        // promise.fail = list.add
                        promise[tuple[1]] = list.add;

                        // Handle state
                        if (stateString) {
                            list.add(
                                function () {

                                    // state = "resolved" (i.e., fulfilled)
                                    // state = "rejected"
                                    state = stateString;
                                },

                                // rejected_callbacks.disable
                                // fulfilled_callbacks.disable
                                tuples[3 - i][2].disable,

                                // progress_callbacks.lock
                                tuples[0][2].lock
                            );
                        }

                        // progress_handlers.fire
                        // fulfilled_handlers.fire
                        // rejected_handlers.fire
                        list.add(tuple[3].fire);

                        // deferred.notify = function() { deferred.notifyWith(...) }
                        // deferred.resolve = function() { deferred.resolveWith(...) }
                        // deferred.reject = function() { deferred.rejectWith(...) }
                        deferred[tuple[0]] = function () {
                            deferred[tuple[0] + "With"](this === deferred ? undefined : this, arguments);
                            return this;
                        };

                        // deferred.notifyWith = list.fireWith
                        // deferred.resolveWith = list.fireWith
                        // deferred.rejectWith = list.fireWith
                        deferred[tuple[0] + "With"] = list.fireWith;
                    });

                    // Make the deferred a promise
                    promise.promise(deferred);

                    // Call given func if any
                    if (func) {
                        func.call(deferred, deferred);
                    }

                    // All done!
                    return deferred;
                },

                // Deferred helper
                when: function (singleValue) {
                    var

                        // count of uncompleted subordinates
                        remaining = arguments.length,

                        // count of unprocessed arguments
                        i = remaining,

                        // subordinate fulfillment data
                        resolveContexts = Array(i),
                        resolveValues = slice.call(arguments),

                        // the master Deferred
                        master = jQuery.Deferred(),

                        // subordinate callback factory
                        updateFunc = function (i) {
                            return function (value) {
                                resolveContexts[i] = this;
                                resolveValues[i] = arguments.length > 1 ? slice.call(arguments) : value;
                                if (!(--remaining)) {
                                    master.resolveWith(resolveContexts, resolveValues);
                                }
                            };
                        };

                    // Single- and empty arguments are adopted like Promise.resolve
                    if (remaining <= 1) {
                        adoptValue(singleValue, master.done(updateFunc(i)).resolve, master.reject,
                            !remaining);

                        // Use .then() to unwrap secondary thenables (cf. gh-3000)
                        if (master.state() === "pending" ||
                            jQuery.isFunction(resolveValues[i] && resolveValues[i].then)) {

                            return master.then();
                        }
                    }

                    // Multiple arguments are aggregated like Promise.all array elements
                    while (i--) {
                        adoptValue(resolveValues[i], updateFunc(i), master.reject);
                    }

                    return master.promise();
                }
            });


            // These usually indicate a programmer mistake during development,
            // warn about them ASAP rather than swallowing them by default.
            var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;

            jQuery.Deferred.exceptionHook = function (error, stack) {

                // Support: IE 8 - 9 only
                // Console exists when dev tools are open, which can happen at any time
                if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
                    window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack);
                }
            };




            jQuery.readyException = function (error) {
                window.setTimeout(function () {
                    throw error;
                });
            };




            // The deferred used on DOM ready
            var readyList = jQuery.Deferred();

            jQuery.fn.ready = function (fn) {

                readyList
                    .then(fn)

                    // Wrap jQuery.readyException in a function so that the lookup
                    // happens at the time of error handling instead of callback
                    // registration.
                    .catch(function (error) {
                        jQuery.readyException(error);
                    });

                return this;
            };

            jQuery.extend({

                // Is the DOM ready to be used? Set to true once it occurs.
                isReady: false,

                // A counter to track how many items to wait for before
                // the ready event fires. See #6781
                readyWait: 1,

                // Handle when the DOM is ready
                ready: function (wait) {

                    // Abort if there are pending holds or we're already ready
                    if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
                        return;
                    }

                    // Remember that the DOM is ready
                    jQuery.isReady = true;

                    // If a normal DOM Ready event fired, decrement, and wait if need be
                    if (wait !== true && --jQuery.readyWait > 0) {
                        return;
                    }

                    // If there are functions bound, to execute
                    readyList.resolveWith(document, [jQuery]);
                }
            });

            jQuery.ready.then = readyList.then;

            // The ready event handler and self cleanup method
            function completed() {
                document.removeEventListener("DOMContentLoaded", completed);
                window.removeEventListener("load", completed);
                jQuery.ready();
            }

            // Catch cases where $(document).ready() is called
            // after the browser event has already occurred.
            // Support: IE <=9 - 10 only
            // Older IE sometimes signals "interactive" too soon
            if (document.readyState === "complete" ||
                (document.readyState !== "loading" && !document.documentElement.doScroll)) {

                // Handle it asynchronously to allow scripts the opportunity to delay ready
                window.setTimeout(jQuery.ready);

            } else {

                // Use the handy event callback
                document.addEventListener("DOMContentLoaded", completed);

                // A fallback to window.onload, that will always work
                window.addEventListener("load", completed);
            }




            // Multifunctional method to get and set values of a collection
            // The value/s can optionally be executed if it's a function
            var access = function (elems, fn, key, value, chainable, emptyGet, raw) {
                var i = 0,
                    len = elems.length,
                    bulk = key == null;

                // Sets many values
                if (jQuery.type(key) === "object") {
                    chainable = true;
                    for (i in key) {
                        access(elems, fn, i, key[i], true, emptyGet, raw);
                    }

                    // Sets one value
                } else if (value !== undefined) {
                    chainable = true;

                    if (!jQuery.isFunction(value)) {
                        raw = true;
                    }

                    if (bulk) {

                        // Bulk operations run against the entire set
                        if (raw) {
                            fn.call(elems, value);
                            fn = null;

                            // ...except when executing function values
                        } else {
                            bulk = fn;
                            fn = function (elem, key, value) {
                                return bulk.call(jQuery(elem), value);
                            };
                        }
                    }

                    if (fn) {
                        for (; i < len; i++) {
                            fn(
                                elems[i], key, raw ?
                                value :
                                value.call(elems[i], i, fn(elems[i], key))
                            );
                        }
                    }
                }

                if (chainable) {
                    return elems;
                }

                // Gets
                if (bulk) {
                    return fn.call(elems);
                }

                return len ? fn(elems[0], key) : emptyGet;
            };
            var acceptData = function (owner) {

                // Accepts only:
                //  - Node
                //    - Node.ELEMENT_NODE
                //    - Node.DOCUMENT_NODE
                //  - Object
                //    - Any
                return owner.nodeType === 1 || owner.nodeType === 9 || !(+owner.nodeType);
            };




            function Data() {
                this.expando = jQuery.expando + Data.uid++;
            }

            Data.uid = 1;

            Data.prototype = {

                cache: function (owner) {

                    // Check if the owner object already has a cache
                    var value = owner[this.expando];

                    // If not, create one
                    if (!value) {
                        value = {};

                        // We can accept data for non-element nodes in modern browsers,
                        // but we should not, see #8335.
                        // Always return an empty object.
                        if (acceptData(owner)) {

                            // If it is a node unlikely to be stringify-ed or looped over
                            // use plain assignment
                            if (owner.nodeType) {
                                owner[this.expando] = value;

                                // Otherwise secure it in a non-enumerable property
                                // configurable must be true to allow the property to be
                                // deleted when data is removed
                            } else {
                                Object.defineProperty(owner, this.expando, {
                                    value: value,
                                    configurable: true
                                });
                            }
                        }
                    }

                    return value;
                },
                set: function (owner, data, value) {
                    var prop,
                        cache = this.cache(owner);

                    // Handle: [ owner, key, value ] args
                    // Always use camelCase key (gh-2257)
                    if (typeof data === "string") {
                        cache[jQuery.camelCase(data)] = value;

                        // Handle: [ owner, { properties } ] args
                    } else {

                        // Copy the properties one-by-one to the cache object
                        for (prop in data) {
                            cache[jQuery.camelCase(prop)] = data[prop];
                        }
                    }
                    return cache;
                },
                get: function (owner, key) {
                    return key === undefined ?
                        this.cache(owner) :

                        // Always use camelCase key (gh-2257)
                        owner[this.expando] && owner[this.expando][jQuery.camelCase(key)];
                },
                access: function (owner, key, value) {

                    // In cases where either:
                    //
                    //   1. No key was specified
                    //   2. A string key was specified, but no value provided
                    //
                    // Take the "read" path and allow the get method to determine
                    // which value to return, respectively either:
                    //
                    //   1. The entire cache object
                    //   2. The data stored at the key
                    //
                    if (key === undefined ||
                        ((key && typeof key === "string") && value === undefined)) {

                        return this.get(owner, key);
                    }

                    // When the key is not a string, or both a key and value
                    // are specified, set or extend (existing objects) with either:
                    //
                    //   1. An object of properties
                    //   2. A key and value
                    //
                    this.set(owner, key, value);

                    // Since the "set" path can have two possible entry points
                    // return the expected data based on which path was taken[*]
                    return value !== undefined ? value : key;
                },
                remove: function (owner, key) {
                    var i,
                        cache = owner[this.expando];

                    if (cache === undefined) {
                        return;
                    }

                    if (key !== undefined) {

                        // Support array or space separated string of keys
                        if (Array.isArray(key)) {

                            // If key is an array of keys...
                            // We always set camelCase keys, so remove that.
                            key = key.map(jQuery.camelCase);
                        } else {
                            key = jQuery.camelCase(key);

                            // If a key with the spaces exists, use it.
                            // Otherwise, create an array by matching non-whitespace
                            key = key in cache ?
                                [key] :
                                (key.match(rnothtmlwhite) || []);
                        }

                        i = key.length;

                        while (i--) {
                            delete cache[key[i]];
                        }
                    }

                    // Remove the expando if there's no more data
                    if (key === undefined || jQuery.isEmptyObject(cache)) {

                        // Support: Chrome <=35 - 45
                        // Webkit & Blink performance suffers when deleting properties
                        // from DOM nodes, so set to undefined instead
                        // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
                        if (owner.nodeType) {
                            owner[this.expando] = undefined;
                        } else {
                            delete owner[this.expando];
                        }
                    }
                },
                hasData: function (owner) {
                    var cache = owner[this.expando];
                    return cache !== undefined && !jQuery.isEmptyObject(cache);
                }
            };
            var dataPriv = new Data();

            var dataUser = new Data();



            //	Implementation Summary
            //
            //	1. Enforce API surface and semantic compatibility with 1.9.x branch
            //	2. Improve the module's maintainability by reducing the storage
            //		paths to a single mechanism.
            //	3. Use the same single mechanism to support "private" and "user" data.
            //	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
            //	5. Avoid exposing implementation details on user objects (eg. expando properties)
            //	6. Provide a clear path for implementation upgrade to WeakMap in 2014

            var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
                rmultiDash = /[A-Z]/g;

            function getData(data) {
                if (data === "true") {
                    return true;
                }

                if (data === "false") {
                    return false;
                }

                if (data === "null") {
                    return null;
                }

                // Only convert to a number if it doesn't change the string
                if (data === +data + "") {
                    return +data;
                }

                if (rbrace.test(data)) {
                    return JSON.parse(data);
                }

                return data;
            }

            function dataAttr(elem, key, data) {
                var name;

                // If nothing was found internally, try to fetch any
                // data from the HTML5 data-* attribute
                if (data === undefined && elem.nodeType === 1) {
                    name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
                    data = elem.getAttribute(name);

                    if (typeof data === "string") {
                        try {
                            data = getData(data);
                        } catch (e) { }

                        // Make sure we set the data so it isn't changed later
                        dataUser.set(elem, key, data);
                    } else {
                        data = undefined;
                    }
                }
                return data;
            }

            jQuery.extend({
                hasData: function (elem) {
                    return dataUser.hasData(elem) || dataPriv.hasData(elem);
                },

                data: function (elem, name, data) {
                    return dataUser.access(elem, name, data);
                },

                removeData: function (elem, name) {
                    dataUser.remove(elem, name);
                },

                // TODO: Now that all calls to _data and _removeData have been replaced
                // with direct calls to dataPriv methods, these can be deprecated.
                _data: function (elem, name, data) {
                    return dataPriv.access(elem, name, data);
                },

                _removeData: function (elem, name) {
                    dataPriv.remove(elem, name);
                }
            });

            jQuery.fn.extend({
                data: function (key, value) {
                    var i, name, data,
                        elem = this[0],
                        attrs = elem && elem.attributes;

                    // Gets all values
                    if (key === undefined) {
                        if (this.length) {
                            data = dataUser.get(elem);

                            if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
                                i = attrs.length;
                                while (i--) {

                                    // Support: IE 11 only
                                    // The attrs elements can be null (#14894)
                                    if (attrs[i]) {
                                        name = attrs[i].name;
                                        if (name.indexOf("data-") === 0) {
                                            name = jQuery.camelCase(name.slice(5));
                                            dataAttr(elem, name, data[name]);
                                        }
                                    }
                                }
                                dataPriv.set(elem, "hasDataAttrs", true);
                            }
                        }

                        return data;
                    }

                    // Sets multiple values
                    if (typeof key === "object") {
                        return this.each(function () {
                            dataUser.set(this, key);
                        });
                    }

                    return access(this, function (value) {
                        var data;

                        // The calling jQuery object (element matches) is not empty
                        // (and therefore has an element appears at this[ 0 ]) and the
                        // `value` parameter was not undefined. An empty jQuery object
                        // will result in `undefined` for elem = this[ 0 ] which will
                        // throw an exception if an attempt to read a data cache is made.
                        if (elem && value === undefined) {

                            // Attempt to get data from the cache
                            // The key will always be camelCased in Data
                            data = dataUser.get(elem, key);
                            if (data !== undefined) {
                                return data;
                            }

                            // Attempt to "discover" the data in
                            // HTML5 custom data-* attrs
                            data = dataAttr(elem, key);
                            if (data !== undefined) {
                                return data;
                            }

                            // We tried really hard, but the data doesn't exist.
                            return;
                        }

                        // Set the data...
                        this.each(function () {

                            // We always store the camelCased key
                            dataUser.set(this, key, value);
                        });
                    }, null, value, arguments.length > 1, null, true);
                },

                removeData: function (key) {
                    return this.each(function () {
                        dataUser.remove(this, key);
                    });
                }
            });


            jQuery.extend({
                queue: function (elem, type, data) {
                    var queue;

                    if (elem) {
                        type = (type || "fx") + "queue";
                        queue = dataPriv.get(elem, type);

                        // Speed up dequeue by getting out quickly if this is just a lookup
                        if (data) {
                            if (!queue || Array.isArray(data)) {
                                queue = dataPriv.access(elem, type, jQuery.makeArray(data));
                            } else {
                                queue.push(data);
                            }
                        }
                        return queue || [];
                    }
                },

                dequeue: function (elem, type) {
                    type = type || "fx";

                    var queue = jQuery.queue(elem, type),
                        startLength = queue.length,
                        fn = queue.shift(),
                        hooks = jQuery._queueHooks(elem, type),
                        next = function () {
                            jQuery.dequeue(elem, type);
                        };

                    // If the fx queue is dequeued, always remove the progress sentinel
                    if (fn === "inprogress") {
                        fn = queue.shift();
                        startLength--;
                    }

                    if (fn) {

                        // Add a progress sentinel to prevent the fx queue from being
                        // automatically dequeued
                        if (type === "fx") {
                            queue.unshift("inprogress");
                        }

                        // Clear up the last queue stop function
                        delete hooks.stop;
                        fn.call(elem, next, hooks);
                    }

                    if (!startLength && hooks) {
                        hooks.empty.fire();
                    }
                },

                // Not public - generate a queueHooks object, or return the current one
                _queueHooks: function (elem, type) {
                    var key = type + "queueHooks";
                    return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
                        empty: jQuery.Callbacks("once memory").add(function () {
                            dataPriv.remove(elem, [type + "queue", key]);
                        })
                    });
                }
            });

            jQuery.fn.extend({
                queue: function (type, data) {
                    var setter = 2;

                    if (typeof type !== "string") {
                        data = type;
                        type = "fx";
                        setter--;
                    }

                    if (arguments.length < setter) {
                        return jQuery.queue(this[0], type);
                    }

                    return data === undefined ?
                        this :
                        this.each(function () {
                            var queue = jQuery.queue(this, type, data);

                            // Ensure a hooks for this queue
                            jQuery._queueHooks(this, type);

                            if (type === "fx" && queue[0] !== "inprogress") {
                                jQuery.dequeue(this, type);
                            }
                        });
                },
                dequeue: function (type) {
                    return this.each(function () {
                        jQuery.dequeue(this, type);
                    });
                },
                clearQueue: function (type) {
                    return this.queue(type || "fx", []);
                },

                // Get a promise resolved when queues of a certain type
                // are emptied (fx is the type by default)
                promise: function (type, obj) {
                    var tmp,
                        count = 1,
                        defer = jQuery.Deferred(),
                        elements = this,
                        i = this.length,
                        resolve = function () {
                            if (!(--count)) {
                                defer.resolveWith(elements, [elements]);
                            }
                        };

                    if (typeof type !== "string") {
                        obj = type;
                        type = undefined;
                    }
                    type = type || "fx";

                    while (i--) {
                        tmp = dataPriv.get(elements[i], type + "queueHooks");
                        if (tmp && tmp.empty) {
                            count++;
                            tmp.empty.add(resolve);
                        }
                    }
                    resolve();
                    return defer.promise(obj);
                }
            });
            var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;

            var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i");


            var cssExpand = ["Top", "Right", "Bottom", "Left"];

            var isHiddenWithinTree = function (elem, el) {

                // isHiddenWithinTree might be called from jQuery#filter function;
                // in that case, element will be second argument
                elem = el || elem;

                // Inline style trumps all
                return elem.style.display === "none" ||
                    elem.style.display === "" &&

                    // Otherwise, check computed style
                    // Support: Firefox <=43 - 45
                    // Disconnected elements can have computed display: none, so first confirm that elem is
                    // in the document.
                    jQuery.contains(elem.ownerDocument, elem) &&

                    jQuery.css(elem, "display") === "none";
            };

            var swap = function (elem, options, callback, args) {
                var ret, name,
                    old = {};

                // Remember the old values, and insert the new ones
                for (name in options) {
                    old[name] = elem.style[name];
                    elem.style[name] = options[name];
                }

                ret = callback.apply(elem, args || []);

                // Revert the old values
                for (name in options) {
                    elem.style[name] = old[name];
                }

                return ret;
            };




            function adjustCSS(elem, prop, valueParts, tween) {
                var adjusted,
                    scale = 1,
                    maxIterations = 20,
                    currentValue = tween ?
                        function () {
                            return tween.cur();
                        } :
                        function () {
                            return jQuery.css(elem, prop, "");
                        },
                    initial = currentValue(),
                    unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px"),

                    // Starting value computation is required for potential unit mismatches
                    initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" && +initial) &&
                        rcssNum.exec(jQuery.css(elem, prop));

                if (initialInUnit && initialInUnit[3] !== unit) {

                    // Trust units reported by jQuery.css
                    unit = unit || initialInUnit[3];

                    // Make sure we update the tween properties later on
                    valueParts = valueParts || [];

                    // Iteratively approximate from a nonzero starting point
                    initialInUnit = +initial || 1;

                    do {

                        // If previous iteration zeroed out, double until we get *something*.
                        // Use string for doubling so we don't accidentally see scale as unchanged below
                        scale = scale || ".5";

                        // Adjust and apply
                        initialInUnit = initialInUnit / scale;
                        jQuery.style(elem, prop, initialInUnit + unit);

                        // Update scale, tolerating zero or NaN from tween.cur()
                        // Break the loop if scale is unchanged or perfect, or if we've just had enough.
                    } while (
                        scale !== (scale = currentValue() / initial) && scale !== 1 && --maxIterations
                    );
                }

                if (valueParts) {
                    initialInUnit = +initialInUnit || +initial || 0;

                    // Apply relative offset (+=/-=) if specified
                    adjusted = valueParts[1] ?
                        initialInUnit + (valueParts[1] + 1) * valueParts[2] :
                        +valueParts[2];
                    if (tween) {
                        tween.unit = unit;
                        tween.start = initialInUnit;
                        tween.end = adjusted;
                    }
                }
                return adjusted;
            }


            var defaultDisplayMap = {};

            function getDefaultDisplay(elem) {
                var temp,
                    doc = elem.ownerDocument,
                    nodeName = elem.nodeName,
                    display = defaultDisplayMap[nodeName];

                if (display) {
                    return display;
                }

                temp = doc.body.appendChild(doc.createElement(nodeName));
                display = jQuery.css(temp, "display");

                temp.parentNode.removeChild(temp);

                if (display === "none") {
                    display = "block";
                }
                defaultDisplayMap[nodeName] = display;

                return display;
            }

            function showHide(elements, show) {
                var display, elem,
                    values = [],
                    index = 0,
                    length = elements.length;

                // Determine new display value for elements that need to change
                for (; index < length; index++) {
                    elem = elements[index];
                    if (!elem.style) {
                        continue;
                    }

                    display = elem.style.display;
                    if (show) {

                        // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
                        // check is required in this first loop unless we have a nonempty display value (either
                        // inline or about-to-be-restored)
                        if (display === "none") {
                            values[index] = dataPriv.get(elem, "display") || null;
                            if (!values[index]) {
                                elem.style.display = "";
                            }
                        }
                        if (elem.style.display === "" && isHiddenWithinTree(elem)) {
                            values[index] = getDefaultDisplay(elem);
                        }
                    } else {
                        if (display !== "none") {
                            values[index] = "none";

                            // Remember what we're overwriting
                            dataPriv.set(elem, "display", display);
                        }
                    }
                }

                // Set the display of the elements in a second loop to avoid constant reflow
                for (index = 0; index < length; index++) {
                    if (values[index] != null) {
                        elements[index].style.display = values[index];
                    }
                }

                return elements;
            }

            jQuery.fn.extend({
                show: function () {
                    return showHide(this, true);
                },
                hide: function () {
                    return showHide(this);
                },
                toggle: function (state) {
                    if (typeof state === "boolean") {
                        return state ? this.show() : this.hide();
                    }

                    return this.each(function () {
                        if (isHiddenWithinTree(this)) {
                            jQuery(this).show();
                        } else {
                            jQuery(this).hide();
                        }
                    });
                }
            });
            var rcheckableType = (/^(?:checkbox|radio)$/i);

            var rtagName = (/<([a-z][^\/\0>\x20\t\r\n\f]+)/i);

            var rscriptType = (/^$|\/(?:java|ecma)script/i);



            // We have to close these tags to support XHTML (#13200)
            var wrapMap = {

                // Support: IE <=9 only
                option: [1, "<select multiple='multiple'>", "</select>"],

                // XHTML parsers do not magically insert elements in the
                // same way that tag soup parsers do. So we cannot shorten
                // this by omitting <tbody> or other required elements.
                thead: [1, "<table>", "</table>"],
                col: [2, "<table><colgroup>", "</colgroup></table>"],
                tr: [2, "<table><tbody>", "</tbody></table>"],
                td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],

                _default: [0, "", ""]
            };

            // Support: IE <=9 only
            wrapMap.optgroup = wrapMap.option;

            wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
            wrapMap.th = wrapMap.td;


            function getAll(context, tag) {

                // Support: IE <=9 - 11 only
                // Use typeof to avoid zero-argument method invocation on host objects (#15151)
                var ret;

                if (typeof context.getElementsByTagName !== "undefined") {
                    ret = context.getElementsByTagName(tag || "*");

                } else if (typeof context.querySelectorAll !== "undefined") {
                    ret = context.querySelectorAll(tag || "*");

                } else {
                    ret = [];
                }

                if (tag === undefined || tag && nodeName(context, tag)) {
                    return jQuery.merge([context], ret);
                }

                return ret;
            }


            // Mark scripts as having already been evaluated
            function setGlobalEval(elems, refElements) {
                var i = 0,
                    l = elems.length;

                for (; i < l; i++) {
                    dataPriv.set(
                        elems[i],
                        "globalEval",
                        !refElements || dataPriv.get(refElements[i], "globalEval")
                    );
                }
            }


            var rhtml = /<|&#?\w+;/;

            function buildFragment(elems, context, scripts, selection, ignored) {
                var elem, tmp, tag, wrap, contains, j,
                    fragment = context.createDocumentFragment(),
                    nodes = [],
                    i = 0,
                    l = elems.length;

                for (; i < l; i++) {
                    elem = elems[i];

                    if (elem || elem === 0) {

                        // Add nodes directly
                        if (jQuery.type(elem) === "object") {

                            // Support: Android <=4.0 only, PhantomJS 1 only
                            // push.apply(_, arraylike) throws on ancient WebKit
                            jQuery.merge(nodes, elem.nodeType ? [elem] : elem);

                            // Convert non-html into a text node
                        } else if (!rhtml.test(elem)) {
                            nodes.push(context.createTextNode(elem));

                            // Convert html into DOM nodes
                        } else {
                            tmp = tmp || fragment.appendChild(context.createElement("div"));

                            // Deserialize a standard representation
                            tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
                            wrap = wrapMap[tag] || wrapMap._default;
                            tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];

                            // Descend through wrappers to the right content
                            j = wrap[0];
                            while (j--) {
                                tmp = tmp.lastChild;
                            }

                            // Support: Android <=4.0 only, PhantomJS 1 only
                            // push.apply(_, arraylike) throws on ancient WebKit
                            jQuery.merge(nodes, tmp.childNodes);

                            // Remember the top-level container
                            tmp = fragment.firstChild;

                            // Ensure the created nodes are orphaned (#12392)
                            tmp.textContent = "";
                        }
                    }
                }

                // Remove wrapper from fragment
                fragment.textContent = "";

                i = 0;
                while ((elem = nodes[i++])) {

                    // Skip elements already in the context collection (trac-4087)
                    if (selection && jQuery.inArray(elem, selection) > -1) {
                        if (ignored) {
                            ignored.push(elem);
                        }
                        continue;
                    }

                    contains = jQuery.contains(elem.ownerDocument, elem);

                    // Append to fragment
                    tmp = getAll(fragment.appendChild(elem), "script");

                    // Preserve script evaluation history
                    if (contains) {
                        setGlobalEval(tmp);
                    }

                    // Capture executables
                    if (scripts) {
                        j = 0;
                        while ((elem = tmp[j++])) {
                            if (rscriptType.test(elem.type || "")) {
                                scripts.push(elem);
                            }
                        }
                    }
                }

                return fragment;
            }


            (function () {
                var fragment = document.createDocumentFragment(),
                    div = fragment.appendChild(document.createElement("div")),
                    input = document.createElement("input");

                // Support: Android 4.0 - 4.3 only
                // Check state lost if the name is set (#11217)
                // Support: Windows Web Apps (WWA)
                // `name` and `type` must use .setAttribute for WWA (#14901)
                input.setAttribute("type", "radio");
                input.setAttribute("checked", "checked");
                input.setAttribute("name", "t");

                div.appendChild(input);

                // Support: Android <=4.1 only
                // Older WebKit doesn't clone checked state correctly in fragments
                support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;

                // Support: IE <=11 only
                // Make sure textarea (and checkbox) defaultValue is properly cloned
                div.innerHTML = "<textarea>x</textarea>";
                support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
            })();
            var documentElement = document.documentElement;



            var
                rkeyEvent = /^key/,
                rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
                rtypenamespace = /^([^.]*)(?:\.(.+)|)/;

            function returnTrue() {
                return true;
            }

            function returnFalse() {
                return false;
            }

            // Support: IE <=9 only
            // See #13393 for more info
            function safeActiveElement() {
                try {
                    return document.activeElement;
                } catch (err) { }
            }

            function on(elem, types, selector, data, fn, one) {
                var origFn, type;

                // Types can be a map of types/handlers
                if (typeof types === "object") {

                    // ( types-Object, selector, data )
                    if (typeof selector !== "string") {

                        // ( types-Object, data )
                        data = data || selector;
                        selector = undefined;
                    }
                    for (type in types) {
                        on(elem, type, selector, data, types[type], one);
                    }
                    return elem;
                }

                if (data == null && fn == null) {

                    // ( types, fn )
                    fn = selector;
                    data = selector = undefined;
                } else if (fn == null) {
                    if (typeof selector === "string") {

                        // ( types, selector, fn )
                        fn = data;
                        data = undefined;
                    } else {

                        // ( types, data, fn )
                        fn = data;
                        data = selector;
                        selector = undefined;
                    }
                }
                if (fn === false) {
                    fn = returnFalse;
                } else if (!fn) {
                    return elem;
                }

                if (one === 1) {
                    origFn = fn;
                    fn = function (event) {

                        // Can use an empty set, since event contains the info
                        jQuery().off(event);
                        return origFn.apply(this, arguments);
                    };

                    // Use same guid so caller can remove using origFn
                    fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
                }
                return elem.each(function () {
                    jQuery.event.add(this, types, fn, data, selector);
                });
            }

            /*
             * Helper functions for managing events -- not part of the public interface.
             * Props to Dean Edwards' addEvent library for many of the ideas.
             */
            jQuery.event = {

                global: {},

                add: function (elem, types, handler, data, selector) {

                    var handleObjIn, eventHandle, tmp,
                        events, t, handleObj,
                        special, handlers, type, namespaces, origType,
                        elemData = dataPriv.get(elem);

                    // Don't attach events to noData or text/comment nodes (but allow plain objects)
                    if (!elemData) {
                        return;
                    }

                    // Caller can pass in an object of custom data in lieu of the handler
                    if (handler.handler) {
                        handleObjIn = handler;
                        handler = handleObjIn.handler;
                        selector = handleObjIn.selector;
                    }

                    // Ensure that invalid selectors throw exceptions at attach time
                    // Evaluate against documentElement in case elem is a non-element node (e.g., document)
                    if (selector) {
                        jQuery.find.matchesSelector(documentElement, selector);
                    }

                    // Make sure that the handler has a unique ID, used to find/remove it later
                    if (!handler.guid) {
                        handler.guid = jQuery.guid++;
                    }

                    // Init the element's event structure and main handler, if this is the first
                    if (!(events = elemData.events)) {
                        events = elemData.events = {};
                    }
                    if (!(eventHandle = elemData.handle)) {
                        eventHandle = elemData.handle = function (e) {

                            // Discard the second event of a jQuery.event.trigger() and
                            // when an event is called after a page has unloaded
                            return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
                                jQuery.event.dispatch.apply(elem, arguments) : undefined;
                        };
                    }

                    // Handle multiple events separated by a space
                    types = (types || "").match(rnothtmlwhite) || [""];
                    t = types.length;
                    while (t--) {
                        tmp = rtypenamespace.exec(types[t]) || [];
                        type = origType = tmp[1];
                        namespaces = (tmp[2] || "").split(".").sort();

                        // There *must* be a type, no attaching namespace-only handlers
                        if (!type) {
                            continue;
                        }

                        // If event changes its type, use the special event handlers for the changed type
                        special = jQuery.event.special[type] || {};

                        // If selector defined, determine special event api type, otherwise given type
                        type = (selector ? special.delegateType : special.bindType) || type;

                        // Update special based on newly reset type
                        special = jQuery.event.special[type] || {};

                        // handleObj is passed to all event handlers
                        handleObj = jQuery.extend({
                            type: type,
                            origType: origType,
                            data: data,
                            handler: handler,
                            guid: handler.guid,
                            selector: selector,
                            needsContext: selector && jQuery.expr.match.needsContext.test(selector),
                            namespace: namespaces.join(".")
                        }, handleObjIn);

                        // Init the event handler queue if we're the first
                        if (!(handlers = events[type])) {
                            handlers = events[type] = [];
                            handlers.delegateCount = 0;

                            // Only use addEventListener if the special events handler returns false
                            if (!special.setup ||
                                special.setup.call(elem, data, namespaces, eventHandle) === false) {

                                if (elem.addEventListener) {
                                    elem.addEventListener(type, eventHandle);
                                }
                            }
                        }

                        if (special.add) {
                            special.add.call(elem, handleObj);

                            if (!handleObj.handler.guid) {
                                handleObj.handler.guid = handler.guid;
                            }
                        }

                        // Add to the element's handler list, delegates in front
                        if (selector) {
                            handlers.splice(handlers.delegateCount++, 0, handleObj);
                        } else {
                            handlers.push(handleObj);
                        }

                        // Keep track of which events have ever been used, for event optimization
                        jQuery.event.global[type] = true;
                    }

                },

                // Detach an event or set of events from an element
                remove: function (elem, types, handler, selector, mappedTypes) {

                    var j, origCount, tmp,
                        events, t, handleObj,
                        special, handlers, type, namespaces, origType,
                        elemData = dataPriv.hasData(elem) && dataPriv.get(elem);

                    if (!elemData || !(events = elemData.events)) {
                        return;
                    }

                    // Once for each type.namespace in types; type may be omitted
                    types = (types || "").match(rnothtmlwhite) || [""];
                    t = types.length;
                    while (t--) {
                        tmp = rtypenamespace.exec(types[t]) || [];
                        type = origType = tmp[1];
                        namespaces = (tmp[2] || "").split(".").sort();

                        // Unbind all events (on this namespace, if provided) for the element
                        if (!type) {
                            for (type in events) {
                                jQuery.event.remove(elem, type + types[t], handler, selector, true);
                            }
                            continue;
                        }

                        special = jQuery.event.special[type] || {};
                        type = (selector ? special.delegateType : special.bindType) || type;
                        handlers = events[type] || [];
                        tmp = tmp[2] &&
                            new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");

                        // Remove matching events
                        origCount = j = handlers.length;
                        while (j--) {
                            handleObj = handlers[j];

                            if ((mappedTypes || origType === handleObj.origType) &&
                                (!handler || handler.guid === handleObj.guid) &&
                                (!tmp || tmp.test(handleObj.namespace)) &&
                                (!selector || selector === handleObj.selector ||
                                    selector === "**" && handleObj.selector)) {
                                handlers.splice(j, 1);

                                if (handleObj.selector) {
                                    handlers.delegateCount--;
                                }
                                if (special.remove) {
                                    special.remove.call(elem, handleObj);
                                }
                            }
                        }

                        // Remove generic event handler if we removed something and no more handlers exist
                        // (avoids potential for endless recursion during removal of special event handlers)
                        if (origCount && !handlers.length) {
                            if (!special.teardown ||
                                special.teardown.call(elem, namespaces, elemData.handle) === false) {

                                jQuery.removeEvent(elem, type, elemData.handle);
                            }

                            delete events[type];
                        }
                    }

                    // Remove data and the expando if it's no longer used
                    if (jQuery.isEmptyObject(events)) {
                        dataPriv.remove(elem, "handle events");
                    }
                },

                dispatch: function (nativeEvent) {

                    // Make a writable jQuery.Event from the native event object
                    var event = jQuery.event.fix(nativeEvent);

                    var i, j, ret, matched, handleObj, handlerQueue,
                        args = new Array(arguments.length),
                        handlers = (dataPriv.get(this, "events") || {})[event.type] || [],
                        special = jQuery.event.special[event.type] || {};

                    // Use the fix-ed jQuery.Event rather than the (read-only) native event
                    args[0] = event;

                    for (i = 1; i < arguments.length; i++) {
                        args[i] = arguments[i];
                    }

                    event.delegateTarget = this;

                    // Call the preDispatch hook for the mapped type, and let it bail if desired
                    if (special.preDispatch && special.preDispatch.call(this, event) === false) {
                        return;
                    }

                    // Determine handlers
                    handlerQueue = jQuery.event.handlers.call(this, event, handlers);

                    // Run delegates first; they may want to stop propagation beneath us
                    i = 0;
                    while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
                        event.currentTarget = matched.elem;

                        j = 0;
                        while ((handleObj = matched.handlers[j++]) &&
                            !event.isImmediatePropagationStopped()) {

                            // Triggered event must either 1) have no namespace, or 2) have namespace(s)
                            // a subset or equal to those in the bound event (both can have no namespace).
                            if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) {

                                event.handleObj = handleObj;
                                event.data = handleObj.data;

                                ret = ((jQuery.event.special[handleObj.origType] || {}).handle ||
                                    handleObj.handler).apply(matched.elem, args);

                                if (ret !== undefined) {
                                    if ((event.result = ret) === false) {
                                        event.preventDefault();
                                        event.stopPropagation();
                                    }
                                }
                            }
                        }
                    }

                    // Call the postDispatch hook for the mapped type
                    if (special.postDispatch) {
                        special.postDispatch.call(this, event);
                    }

                    return event.result;
                },

                handlers: function (event, handlers) {
                    var i, handleObj, sel, matchedHandlers, matchedSelectors,
                        handlerQueue = [],
                        delegateCount = handlers.delegateCount,
                        cur = event.target;

                    // Find delegate handlers
                    if (delegateCount &&

                        // Support: IE <=9
                        // Black-hole SVG <use> instance trees (trac-13180)
                        cur.nodeType &&

                        // Support: Firefox <=42
                        // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
                        // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
                        // Support: IE 11 only
                        // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
                        !(event.type === "click" && event.button >= 1)) {

                        for (; cur !== this; cur = cur.parentNode || this) {

                            // Don't check non-elements (#13208)
                            // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
                            if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) {
                                matchedHandlers = [];
                                matchedSelectors = {};
                                for (i = 0; i < delegateCount; i++) {
                                    handleObj = handlers[i];

                                    // Don't conflict with Object.prototype properties (#13203)
                                    sel = handleObj.selector + " ";

                                    if (matchedSelectors[sel] === undefined) {
                                        matchedSelectors[sel] = handleObj.needsContext ?
                                            jQuery(sel, this).index(cur) > -1 :
                                            jQuery.find(sel, this, null, [cur]).length;
                                    }
                                    if (matchedSelectors[sel]) {
                                        matchedHandlers.push(handleObj);
                                    }
                                }
                                if (matchedHandlers.length) {
                                    handlerQueue.push({ elem: cur, handlers: matchedHandlers });
                                }
                            }
                        }
                    }

                    // Add the remaining (directly-bound) handlers
                    cur = this;
                    if (delegateCount < handlers.length) {
                        handlerQueue.push({ elem: cur, handlers: handlers.slice(delegateCount) });
                    }

                    return handlerQueue;
                },

                addProp: function (name, hook) {
                    Object.defineProperty(jQuery.Event.prototype, name, {
                        enumerable: true,
                        configurable: true,

                        get: jQuery.isFunction(hook) ?
                            function () {
                                if (this.originalEvent) {
                                    return hook(this.originalEvent);
                                }
                            } :
                            function () {
                                if (this.originalEvent) {
                                    return this.originalEvent[name];
                                }
                            },

                        set: function (value) {
                            Object.defineProperty(this, name, {
                                enumerable: true,
                                configurable: true,
                                writable: true,
                                value: value
                            });
                        }
                    });
                },

                fix: function (originalEvent) {
                    return originalEvent[jQuery.expando] ?
                        originalEvent :
                        new jQuery.Event(originalEvent);
                },

                special: {
                    load: {

                        // Prevent triggered image.load events from bubbling to window.load
                        noBubble: true
                    },
                    focus: {

                        // Fire native event if possible so blur/focus sequence is correct
                        trigger: function () {
                            if (this !== safeActiveElement() && this.focus) {
                                this.focus();
                                return false;
                            }
                        },
                        delegateType: "focusin"
                    },
                    blur: {
                        trigger: function () {
                            if (this === safeActiveElement() && this.blur) {
                                this.blur();
                                return false;
                            }
                        },
                        delegateType: "focusout"
                    },
                    click: {

                        // For checkbox, fire native event so checked state will be right
                        trigger: function () {
                            if (this.type === "checkbox" && this.click && nodeName(this, "input")) {
                                this.click();
                                return false;
                            }
                        },

                        // For cross-browser consistency, don't fire native .click() on links
                        _default: function (event) {
                            return nodeName(event.target, "a");
                        }
                    },

                    beforeunload: {
                        postDispatch: function (event) {

                            // Support: Firefox 20+
                            // Firefox doesn't alert if the returnValue field is not set.
                            if (event.result !== undefined && event.originalEvent) {
                                event.originalEvent.returnValue = event.result;
                            }
                        }
                    }
                }
            };

            jQuery.removeEvent = function (elem, type, handle) {

                // This "if" is needed for plain objects
                if (elem.removeEventListener) {
                    elem.removeEventListener(type, handle);
                }
            };

            jQuery.Event = function (src, props) {

                // Allow instantiation without the 'new' keyword
                if (!(this instanceof jQuery.Event)) {
                    return new jQuery.Event(src, props);
                }

                // Event object
                if (src && src.type) {
                    this.originalEvent = src;
                    this.type = src.type;

                    // Events bubbling up the document may have been marked as prevented
                    // by a handler lower down the tree; reflect the correct value.
                    this.isDefaultPrevented = src.defaultPrevented ||
                        src.defaultPrevented === undefined &&

                        // Support: Android <=2.3 only
                        src.returnValue === false ?
                        returnTrue :
                        returnFalse;

                    // Create target properties
                    // Support: Safari <=6 - 7 only
                    // Target should not be a text node (#504, #13143)
                    this.target = (src.target && src.target.nodeType === 3) ?
                        src.target.parentNode :
                        src.target;

                    this.currentTarget = src.currentTarget;
                    this.relatedTarget = src.relatedTarget;

                    // Event type
                } else {
                    this.type = src;
                }

                // Put explicitly provided properties onto the event object
                if (props) {
                    jQuery.extend(this, props);
                }

                // Create a timestamp if incoming event doesn't have one
                this.timeStamp = src && src.timeStamp || jQuery.now();

                // Mark it as fixed
                this[jQuery.expando] = true;
            };

            // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
            // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
            jQuery.Event.prototype = {
                constructor: jQuery.Event,
                isDefaultPrevented: returnFalse,
                isPropagationStopped: returnFalse,
                isImmediatePropagationStopped: returnFalse,
                isSimulated: false,

                preventDefault: function () {
                    var e = this.originalEvent;

                    this.isDefaultPrevented = returnTrue;

                    if (e && !this.isSimulated) {
                        e.preventDefault();
                    }
                },
                stopPropagation: function () {
                    var e = this.originalEvent;

                    this.isPropagationStopped = returnTrue;

                    if (e && !this.isSimulated) {
                        e.stopPropagation();
                    }
                },
                stopImmediatePropagation: function () {
                    var e = this.originalEvent;

                    this.isImmediatePropagationStopped = returnTrue;

                    if (e && !this.isSimulated) {
                        e.stopImmediatePropagation();
                    }

                    this.stopPropagation();
                }
            };

            // Includes all common event props including KeyEvent and MouseEvent specific props
            jQuery.each({
                altKey: true,
                bubbles: true,
                cancelable: true,
                changedTouches: true,
                ctrlKey: true,
                detail: true,
                eventPhase: true,
                metaKey: true,
                pageX: true,
                pageY: true,
                shiftKey: true,
                view: true,
                "char": true,
                charCode: true,
                key: true,
                keyCode: true,
                button: true,
                buttons: true,
                clientX: true,
                clientY: true,
                offsetX: true,
                offsetY: true,
                pointerId: true,
                pointerType: true,
                screenX: true,
                screenY: true,
                targetTouches: true,
                toElement: true,
                touches: true,

                which: function (event) {
                    var button = event.button;

                    // Add which for key events
                    if (event.which == null && rkeyEvent.test(event.type)) {
                        return event.charCode != null ? event.charCode : event.keyCode;
                    }

                    // Add which for click: 1 === left; 2 === middle; 3 === right
                    if (!event.which && button !== undefined && rmouseEvent.test(event.type)) {
                        if (button & 1) {
                            return 1;
                        }

                        if (button & 2) {
                            return 3;
                        }

                        if (button & 4) {
                            return 2;
                        }

                        return 0;
                    }

                    return event.which;
                }
            }, jQuery.event.addProp);

            // Create mouseenter/leave events using mouseover/out and event-time checks
            // so that event delegation works in jQuery.
            // Do the same for pointerenter/pointerleave and pointerover/pointerout
            //
            // Support: Safari 7 only
            // Safari sends mouseenter too often; see:
            // https://bugs.chromium.org/p/chromium/issues/detail?id=470258
            // for the description of the bug (it existed in older Chrome versions as well).
            jQuery.each({
                mouseenter: "mouseover",
                mouseleave: "mouseout",
                pointerenter: "pointerover",
                pointerleave: "pointerout"
            }, function (orig, fix) {
                jQuery.event.special[orig] = {
                    delegateType: fix,
                    bindType: fix,

                    handle: function (event) {
                        var ret,
                            target = this,
                            related = event.relatedTarget,
                            handleObj = event.handleObj;

                        // For mouseenter/leave call the handler if related is outside the target.
                        // NB: No relatedTarget if the mouse left/entered the browser window
                        if (!related || (related !== target && !jQuery.contains(target, related))) {
                            event.type = handleObj.origType;
                            ret = handleObj.handler.apply(this, arguments);
                            event.type = fix;
                        }
                        return ret;
                    }
                };
            });

            jQuery.fn.extend({

                on: function (types, selector, data, fn) {
                    return on(this, types, selector, data, fn);
                },
                one: function (types, selector, data, fn) {
                    return on(this, types, selector, data, fn, 1);
                },
                off: function (types, selector, fn) {
                    var handleObj, type;
                    if (types && types.preventDefault && types.handleObj) {

                        // ( event )  dispatched jQuery.Event
                        handleObj = types.handleObj;
                        jQuery(types.delegateTarget).off(
                            handleObj.namespace ?
                                handleObj.origType + "." + handleObj.namespace :
                                handleObj.origType,
                            handleObj.selector,
                            handleObj.handler
                        );
                        return this;
                    }
                    if (typeof types === "object") {

                        // ( types-object [, selector] )
                        for (type in types) {
                            this.off(type, selector, types[type]);
                        }
                        return this;
                    }
                    if (selector === false || typeof selector === "function") {

                        // ( types [, fn] )
                        fn = selector;
                        selector = undefined;
                    }
                    if (fn === false) {
                        fn = returnFalse;
                    }
                    return this.each(function () {
                        jQuery.event.remove(this, types, fn, selector);
                    });
                }
            });


            var

                /* eslint-disable max-len */

                // See https://github.com/eslint/eslint/issues/3229
                rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,

                /* eslint-enable */

                // Support: IE <=10 - 11, Edge 12 - 13
                // In IE/Edge using regex groups here causes severe slowdowns.
                // See https://connect.microsoft.com/IE/feedback/details/1736512/
                rnoInnerhtml = /<script|<style|<link/i,

                // checked="checked" or checked
                rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
                rscriptTypeMasked = /^true\/(.*)/,
                rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;

            // Prefer a tbody over its parent table for containing new rows
            function manipulationTarget(elem, content) {
                if (nodeName(elem, "table") &&
                    nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) {

                    return jQuery(">tbody", elem)[0] || elem;
                }

                return elem;
            }

            // Replace/restore the type attribute of script elements for safe DOM manipulation
            function disableScript(elem) {
                elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
                return elem;
            }
            function restoreScript(elem) {
                var match = rscriptTypeMasked.exec(elem.type);

                if (match) {
                    elem.type = match[1];
                } else {
                    elem.removeAttribute("type");
                }

                return elem;
            }

            function cloneCopyEvent(src, dest) {
                var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;

                if (dest.nodeType !== 1) {
                    return;
                }

                // 1. Copy private data: events, handlers, etc.
                if (dataPriv.hasData(src)) {
                    pdataOld = dataPriv.access(src);
                    pdataCur = dataPriv.set(dest, pdataOld);
                    events = pdataOld.events;

                    if (events) {
                        delete pdataCur.handle;
                        pdataCur.events = {};

                        for (type in events) {
                            for (i = 0, l = events[type].length; i < l; i++) {
                                jQuery.event.add(dest, type, events[type][i]);
                            }
                        }
                    }
                }

                // 2. Copy user data
                if (dataUser.hasData(src)) {
                    udataOld = dataUser.access(src);
                    udataCur = jQuery.extend({}, udataOld);

                    dataUser.set(dest, udataCur);
                }
            }

            // Fix IE bugs, see support tests
            function fixInput(src, dest) {
                var nodeName = dest.nodeName.toLowerCase();

                // Fails to persist the checked state of a cloned checkbox or radio button.
                if (nodeName === "input" && rcheckableType.test(src.type)) {
                    dest.checked = src.checked;

                    // Fails to return the selected option to the default selected state when cloning options
                } else if (nodeName === "input" || nodeName === "textarea") {
                    dest.defaultValue = src.defaultValue;
                }
            }

            function domManip(collection, args, callback, ignored) {

                // Flatten any nested arrays
                args = concat.apply([], args);

                var fragment, first, scripts, hasScripts, node, doc,
                    i = 0,
                    l = collection.length,
                    iNoClone = l - 1,
                    value = args[0],
                    isFunction = jQuery.isFunction(value);

                // We can't cloneNode fragments that contain checked, in WebKit
                if (isFunction ||
                    (l > 1 && typeof value === "string" &&
                        !support.checkClone && rchecked.test(value))) {
                    return collection.each(function (index) {
                        var self = collection.eq(index);
                        if (isFunction) {
                            args[0] = value.call(this, index, self.html());
                        }
                        domManip(self, args, callback, ignored);
                    });
                }

                if (l) {
                    fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
                    first = fragment.firstChild;

                    if (fragment.childNodes.length === 1) {
                        fragment = first;
                    }

                    // Require either new content or an interest in ignored elements to invoke the callback
                    if (first || ignored) {
                        scripts = jQuery.map(getAll(fragment, "script"), disableScript);
                        hasScripts = scripts.length;

                        // Use the original fragment for the last item
                        // instead of the first because it can end up
                        // being emptied incorrectly in certain situations (#8070).
                        for (; i < l; i++) {
                            node = fragment;

                            if (i !== iNoClone) {
                                node = jQuery.clone(node, true, true);

                                // Keep references to cloned scripts for later restoration
                                if (hasScripts) {

                                    // Support: Android <=4.0 only, PhantomJS 1 only
                                    // push.apply(_, arraylike) throws on ancient WebKit
                                    jQuery.merge(scripts, getAll(node, "script"));
                                }
                            }

                            callback.call(collection[i], node, i);
                        }

                        if (hasScripts) {
                            doc = scripts[scripts.length - 1].ownerDocument;

                            // Reenable scripts
                            jQuery.map(scripts, restoreScript);

                            // Evaluate executable scripts on first document insertion
                            for (i = 0; i < hasScripts; i++) {
                                node = scripts[i];
                                if (rscriptType.test(node.type || "") &&
                                    !dataPriv.access(node, "globalEval") &&
                                    jQuery.contains(doc, node)) {

                                    if (node.src) {

                                        // Optional AJAX dependency, but won't run scripts if not present
                                        if (jQuery._evalUrl) {
                                            jQuery._evalUrl(node.src);
                                        }
                                    } else {
                                        DOMEval(node.textContent.replace(rcleanScript, ""), doc);
                                    }
                                }
                            }
                        }
                    }
                }

                return collection;
            }

            function remove(elem, selector, keepData) {
                var node,
                    nodes = selector ? jQuery.filter(selector, elem) : elem,
                    i = 0;

                for (; (node = nodes[i]) != null; i++) {
                    if (!keepData && node.nodeType === 1) {
                        jQuery.cleanData(getAll(node));
                    }

                    if (node.parentNode) {
                        if (keepData && jQuery.contains(node.ownerDocument, node)) {
                            setGlobalEval(getAll(node, "script"));
                        }
                        node.parentNode.removeChild(node);
                    }
                }

                return elem;
            }

            jQuery.extend({
                htmlPrefilter: function (html) {
                    return html.replace(rxhtmlTag, "<$1></$2>");
                },

                clone: function (elem, dataAndEvents, deepDataAndEvents) {
                    var i, l, srcElements, destElements,
                        clone = elem.cloneNode(true),
                        inPage = jQuery.contains(elem.ownerDocument, elem);

                    // Fix IE cloning issues
                    if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) &&
                        !jQuery.isXMLDoc(elem)) {

                        // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
                        destElements = getAll(clone);
                        srcElements = getAll(elem);

                        for (i = 0, l = srcElements.length; i < l; i++) {
                            fixInput(srcElements[i], destElements[i]);
                        }
                    }

                    // Copy the events from the original to the clone
                    if (dataAndEvents) {
                        if (deepDataAndEvents) {
                            srcElements = srcElements || getAll(elem);
                            destElements = destElements || getAll(clone);

                            for (i = 0, l = srcElements.length; i < l; i++) {
                                cloneCopyEvent(srcElements[i], destElements[i]);
                            }
                        } else {
                            cloneCopyEvent(elem, clone);
                        }
                    }

                    // Preserve script evaluation history
                    destElements = getAll(clone, "script");
                    if (destElements.length > 0) {
                        setGlobalEval(destElements, !inPage && getAll(elem, "script"));
                    }

                    // Return the cloned set
                    return clone;
                },

                cleanData: function (elems) {
                    var data, elem, type,
                        special = jQuery.event.special,
                        i = 0;

                    for (; (elem = elems[i]) !== undefined; i++) {
                        if (acceptData(elem)) {
                            if ((data = elem[dataPriv.expando])) {
                                if (data.events) {
                                    for (type in data.events) {
                                        if (special[type]) {
                                            jQuery.event.remove(elem, type);

                                            // This is a shortcut to avoid jQuery.event.remove's overhead
                                        } else {
                                            jQuery.removeEvent(elem, type, data.handle);
                                        }
                                    }
                                }

                                // Support: Chrome <=35 - 45+
                                // Assign undefined instead of using delete, see Data#remove
                                elem[dataPriv.expando] = undefined;
                            }
                            if (elem[dataUser.expando]) {

                                // Support: Chrome <=35 - 45+
                                // Assign undefined instead of using delete, see Data#remove
                                elem[dataUser.expando] = undefined;
                            }
                        }
                    }
                }
            });

            jQuery.fn.extend({
                detach: function (selector) {
                    return remove(this, selector, true);
                },

                remove: function (selector) {
                    return remove(this, selector);
                },

                text: function (value) {
                    return access(this, function (value) {
                        return value === undefined ?
                            jQuery.text(this) :
                            this.empty().each(function () {
                                if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
                                    this.textContent = value;
                                }
                            });
                    }, null, value, arguments.length);
                },

                append: function () {
                    return domManip(this, arguments, function (elem) {
                        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
                            var target = manipulationTarget(this, elem);
                            target.appendChild(elem);
                        }
                    });
                },

                prepend: function () {
                    return domManip(this, arguments, function (elem) {
                        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
                            var target = manipulationTarget(this, elem);
                            target.insertBefore(elem, target.firstChild);
                        }
                    });
                },

                before: function () {
                    return domManip(this, arguments, function (elem) {
                        if (this.parentNode) {
                            this.parentNode.insertBefore(elem, this);
                        }
                    });
                },

                after: function () {
                    return domManip(this, arguments, function (elem) {
                        if (this.parentNode) {
                            this.parentNode.insertBefore(elem, this.nextSibling);
                        }
                    });
                },

                empty: function () {
                    var elem,
                        i = 0;

                    for (; (elem = this[i]) != null; i++) {
                        if (elem.nodeType === 1) {

                            // Prevent memory leaks
                            jQuery.cleanData(getAll(elem, false));

                            // Remove any remaining nodes
                            elem.textContent = "";
                        }
                    }

                    return this;
                },

                clone: function (dataAndEvents, deepDataAndEvents) {
                    dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
                    deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

                    return this.map(function () {
                        return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
                    });
                },

                html: function (value) {
                    return access(this, function (value) {
                        var elem = this[0] || {},
                            i = 0,
                            l = this.length;

                        if (value === undefined && elem.nodeType === 1) {
                            return elem.innerHTML;
                        }

                        // See if we can take a shortcut and just use innerHTML
                        if (typeof value === "string" && !rnoInnerhtml.test(value) &&
                            !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {

                            value = jQuery.htmlPrefilter(value);

                            try {
                                for (; i < l; i++) {
                                    elem = this[i] || {};

                                    // Remove element nodes and prevent memory leaks
                                    if (elem.nodeType === 1) {
                                        jQuery.cleanData(getAll(elem, false));
                                        elem.innerHTML = value;
                                    }
                                }

                                elem = 0;

                                // If using innerHTML throws an exception, use the fallback method
                            } catch (e) { }
                        }

                        if (elem) {
                            this.empty().append(value);
                        }
                    }, null, value, arguments.length);
                },

                replaceWith: function () {
                    var ignored = [];

                    // Make the changes, replacing each non-ignored context element with the new content
                    return domManip(this, arguments, function (elem) {
                        var parent = this.parentNode;

                        if (jQuery.inArray(this, ignored) < 0) {
                            jQuery.cleanData(getAll(this));
                            if (parent) {
                                parent.replaceChild(elem, this);
                            }
                        }

                        // Force callback invocation
                    }, ignored);
                }
            });

            jQuery.each({
                appendTo: "append",
                prependTo: "prepend",
                insertBefore: "before",
                insertAfter: "after",
                replaceAll: "replaceWith"
            }, function (name, original) {
                jQuery.fn[name] = function (selector) {
                    var elems,
                        ret = [],
                        insert = jQuery(selector),
                        last = insert.length - 1,
                        i = 0;

                    for (; i <= last; i++) {
                        elems = i === last ? this : this.clone(true);
                        jQuery(insert[i])[original](elems);

                        // Support: Android <=4.0 only, PhantomJS 1 only
                        // .get() because push.apply(_, arraylike) throws on ancient WebKit
                        push.apply(ret, elems.get());
                    }

                    return this.pushStack(ret);
                };
            });
            var rmargin = (/^margin/);

            var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i");

            var getStyles = function (elem) {

                // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
                // IE throws on elements created in popups
                // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
                var view = elem.ownerDocument.defaultView;

                if (!view || !view.opener) {
                    view = window;
                }

                return view.getComputedStyle(elem);
            };



            (function () {

                // Executing both pixelPosition & boxSizingReliable tests require only one layout
                // so they're executed at the same time to save the second computation.
                function computeStyleTests() {

                    // This is a singleton, we need to execute it only once
                    if (!div) {
                        return;
                    }

                    div.style.cssText =
                        "box-sizing:border-box;" +
                        "position:relative;display:block;" +
                        "margin:auto;border:1px;padding:1px;" +
                        "top:1%;width:50%";
                    div.innerHTML = "";
                    documentElement.appendChild(container);

                    var divStyle = window.getComputedStyle(div);
                    pixelPositionVal = divStyle.top !== "1%";

                    // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
                    reliableMarginLeftVal = divStyle.marginLeft === "2px";
                    boxSizingReliableVal = divStyle.width === "4px";

                    // Support: Android 4.0 - 4.3 only
                    // Some styles come back with percentage values, even though they shouldn't
                    div.style.marginRight = "50%";
                    pixelMarginRightVal = divStyle.marginRight === "4px";

                    documentElement.removeChild(container);

                    // Nullify the div so it wouldn't be stored in the memory and
                    // it will also be a sign that checks already performed
                    div = null;
                }

                var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
                    container = document.createElement("div"),
                    div = document.createElement("div");

                // Finish early in limited (non-browser) environments
                if (!div.style) {
                    return;
                }

                // Support: IE <=9 - 11 only
                // Style of cloned element affects source element cloned (#8908)
                div.style.backgroundClip = "content-box";
                div.cloneNode(true).style.backgroundClip = "";
                support.clearCloneStyle = div.style.backgroundClip === "content-box";

                container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
                    "padding:0;margin-top:1px;position:absolute";
                container.appendChild(div);

                jQuery.extend(support, {
                    pixelPosition: function () {
                        computeStyleTests();
                        return pixelPositionVal;
                    },
                    boxSizingReliable: function () {
                        computeStyleTests();
                        return boxSizingReliableVal;
                    },
                    pixelMarginRight: function () {
                        computeStyleTests();
                        return pixelMarginRightVal;
                    },
                    reliableMarginLeft: function () {
                        computeStyleTests();
                        return reliableMarginLeftVal;
                    }
                });
            })();


            function curCSS(elem, name, computed) {
                var width, minWidth, maxWidth, ret,

                    // Support: Firefox 51+
                    // Retrieving style before computed somehow
                    // fixes an issue with getting wrong values
                    // on detached elements
                    style = elem.style;

                computed = computed || getStyles(elem);

                // getPropertyValue is needed for:
                //   .css('filter') (IE 9 only, #12537)
                //   .css('--customProperty) (#3144)
                if (computed) {
                    ret = computed.getPropertyValue(name) || computed[name];

                    if (ret === "" && !jQuery.contains(elem.ownerDocument, elem)) {
                        ret = jQuery.style(elem, name);
                    }

                    // A tribute to the "awesome hack by Dean Edwards"
                    // Android Browser returns percentage for some values,
                    // but width seems to be reliably pixels.
                    // This is against the CSSOM draft spec:
                    // https://drafts.csswg.org/cssom/#resolved-values
                    if (!support.pixelMarginRight() && rnumnonpx.test(ret) && rmargin.test(name)) {

                        // Remember the original values
                        width = style.width;
                        minWidth = style.minWidth;
                        maxWidth = style.maxWidth;

                        // Put in the new values to get a computed value out
                        style.minWidth = style.maxWidth = style.width = ret;
                        ret = computed.width;

                        // Revert the changed values
                        style.width = width;
                        style.minWidth = minWidth;
                        style.maxWidth = maxWidth;
                    }
                }

                return ret !== undefined ?

                    // Support: IE <=9 - 11 only
                    // IE returns zIndex value as an integer.
                    ret + "" :
                    ret;
            }


            function addGetHookIf(conditionFn, hookFn) {

                // Define the hook, we'll check on the first run if it's really needed.
                return {
                    get: function () {
                        if (conditionFn()) {

                            // Hook not needed (or it's not possible to use it due
                            // to missing dependency), remove it.
                            delete this.get;
                            return;
                        }

                        // Hook needed; redefine it so that the support test is not executed again.
                        return (this.get = hookFn).apply(this, arguments);
                    }
                };
            }


            var

                // Swappable if display is none or starts with table
                // except "table", "table-cell", or "table-caption"
                // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
                rdisplayswap = /^(none|table(?!-c[ea]).+)/,
                rcustomProp = /^--/,
                cssShow = { position: "absolute", visibility: "hidden", display: "block" },
                cssNormalTransform = {
                    letterSpacing: "0",
                    fontWeight: "400"
                },

                cssPrefixes = ["Webkit", "Moz", "ms"],
                emptyStyle = document.createElement("div").style;

            // Return a css property mapped to a potentially vendor prefixed property
            function vendorPropName(name) {

                // Shortcut for names that are not vendor prefixed
                if (name in emptyStyle) {
                    return name;
                }

                // Check for vendor prefixed names
                var capName = name[0].toUpperCase() + name.slice(1),
                    i = cssPrefixes.length;

                while (i--) {
                    name = cssPrefixes[i] + capName;
                    if (name in emptyStyle) {
                        return name;
                    }
                }
            }

            // Return a property mapped along what jQuery.cssProps suggests or to
            // a vendor prefixed property.
            function finalPropName(name) {
                var ret = jQuery.cssProps[name];
                if (!ret) {
                    ret = jQuery.cssProps[name] = vendorPropName(name) || name;
                }
                return ret;
            }

            function setPositiveNumber(elem, value, subtract) {

                // Any relative (+/-) values have already been
                // normalized at this point
                var matches = rcssNum.exec(value);
                return matches ?

                    // Guard against undefined "subtract", e.g., when used as in cssHooks
                    Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") :
                    value;
            }

            function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
                var i,
                    val = 0;

                // If we already have the right measurement, avoid augmentation
                if (extra === (isBorderBox ? "border" : "content")) {
                    i = 4;

                    // Otherwise initialize for horizontal or vertical properties
                } else {
                    i = name === "width" ? 1 : 0;
                }

                for (; i < 4; i += 2) {

                    // Both box models exclude margin, so add it if we want it
                    if (extra === "margin") {
                        val += jQuery.css(elem, extra + cssExpand[i], true, styles);
                    }

                    if (isBorderBox) {

                        // border-box includes padding, so remove it if we want content
                        if (extra === "content") {
                            val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
                        }

                        // At this point, extra isn't border nor margin, so remove border
                        if (extra !== "margin") {
                            val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
                        }
                    } else {

                        // At this point, extra isn't content, so add padding
                        val += jQuery.css(elem, "padding" + cssExpand[i], true, styles);

                        // At this point, extra isn't content nor padding, so add border
                        if (extra !== "padding") {
                            val += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
                        }
                    }
                }

                return val;
            }

            function getWidthOrHeight(elem, name, extra) {

                // Start with computed style
                var valueIsBorderBox,
                    styles = getStyles(elem),
                    val = curCSS(elem, name, styles),
                    isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box";

                // Computed unit is not pixels. Stop here and return.
                if (rnumnonpx.test(val)) {
                    return val;
                }

                // Check for style in case a browser which returns unreliable values
                // for getComputedStyle silently falls back to the reliable elem.style
                valueIsBorderBox = isBorderBox &&
                    (support.boxSizingReliable() || val === elem.style[name]);

                // Fall back to offsetWidth/Height when value is "auto"
                // This happens for inline elements with no explicit setting (gh-3571)
                if (val === "auto") {
                    val = elem["offset" + name[0].toUpperCase() + name.slice(1)];
                }

                // Normalize "", auto, and prepare for extra
                val = parseFloat(val) || 0;

                // Use the active box-sizing model to add/subtract irrelevant styles
                return (val +
                    augmentWidthOrHeight(
                        elem,
                        name,
                        extra || (isBorderBox ? "border" : "content"),
                        valueIsBorderBox,
                        styles
                    )
                ) + "px";
            }

            jQuery.extend({

                // Add in style property hooks for overriding the default
                // behavior of getting and setting a style property
                cssHooks: {
                    opacity: {
                        get: function (elem, computed) {
                            if (computed) {

                                // We should always get a number back from opacity
                                var ret = curCSS(elem, "opacity");
                                return ret === "" ? "1" : ret;
                            }
                        }
                    }
                },

                // Don't automatically add "px" to these possibly-unitless properties
                cssNumber: {
                    "animationIterationCount": true,
                    "columnCount": true,
                    "fillOpacity": true,
                    "flexGrow": true,
                    "flexShrink": true,
                    "fontWeight": true,
                    "lineHeight": true,
                    "opacity": true,
                    "order": true,
                    "orphans": true,
                    "widows": true,
                    "zIndex": true,
                    "zoom": true
                },

                // Add in properties whose names you wish to fix before
                // setting or getting the value
                cssProps: {
                    "float": "cssFloat"
                },

                // Get and set the style property on a DOM Node
                style: function (elem, name, value, extra) {

                    // Don't set styles on text and comment nodes
                    if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
                        return;
                    }

                    // Make sure that we're working with the right name
                    var ret, type, hooks,
                        origName = jQuery.camelCase(name),
                        isCustomProp = rcustomProp.test(name),
                        style = elem.style;

                    // Make sure that we're working with the right name. We don't
                    // want to query the value if it is a CSS custom property
                    // since they are user-defined.
                    if (!isCustomProp) {
                        name = finalPropName(origName);
                    }

                    // Gets hook for the prefixed version, then unprefixed version
                    hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];

                    // Check if we're setting a value
                    if (value !== undefined) {
                        type = typeof value;

                        // Convert "+=" or "-=" to relative numbers (#7345)
                        if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
                            value = adjustCSS(elem, name, ret);

                            // Fixes bug #9237
                            type = "number";
                        }

                        // Make sure that null and NaN values aren't set (#7116)
                        if (value == null || value !== value) {
                            return;
                        }

                        // If a number was passed in, add the unit (except for certain CSS properties)
                        if (type === "number") {
                            value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px");
                        }

                        // background-* props affect original clone's values
                        if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
                            style[name] = "inherit";
                        }

                        // If a hook was provided, use that value, otherwise just set the specified value
                        if (!hooks || !("set" in hooks) ||
                            (value = hooks.set(elem, value, extra)) !== undefined) {

                            if (isCustomProp) {
                                style.setProperty(name, value);
                            } else {
                                style[name] = value;
                            }
                        }

                    } else {

                        // If a hook was provided get the non-computed value from there
                        if (hooks && "get" in hooks &&
                            (ret = hooks.get(elem, false, extra)) !== undefined) {

                            return ret;
                        }

                        // Otherwise just get the value from the style object
                        return style[name];
                    }
                },

                css: function (elem, name, extra, styles) {
                    var val, num, hooks,
                        origName = jQuery.camelCase(name),
                        isCustomProp = rcustomProp.test(name);

                    // Make sure that we're working with the right name. We don't
                    // want to modify the value if it is a CSS custom property
                    // since they are user-defined.
                    if (!isCustomProp) {
                        name = finalPropName(origName);
                    }

                    // Try prefixed name followed by the unprefixed name
                    hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];

                    // If a hook was provided get the computed value from there
                    if (hooks && "get" in hooks) {
                        val = hooks.get(elem, true, extra);
                    }

                    // Otherwise, if a way to get the computed value exists, use that
                    if (val === undefined) {
                        val = curCSS(elem, name, styles);
                    }

                    // Convert "normal" to computed value
                    if (val === "normal" && name in cssNormalTransform) {
                        val = cssNormalTransform[name];
                    }

                    // Make numeric if forced or a qualifier was provided and val looks numeric
                    if (extra === "" || extra) {
                        num = parseFloat(val);
                        return extra === true || isFinite(num) ? num || 0 : val;
                    }

                    return val;
                }
            });

            jQuery.each(["height", "width"], function (i, name) {
                jQuery.cssHooks[name] = {
                    get: function (elem, computed, extra) {
                        if (computed) {

                            // Certain elements can have dimension info if we invisibly show them
                            // but it must have a current display style that would benefit
                            return rdisplayswap.test(jQuery.css(elem, "display")) &&

                                // Support: Safari 8+
                                // Table columns in Safari have non-zero offsetWidth & zero
                                // getBoundingClientRect().width unless display is changed.
                                // Support: IE <=11 only
                                // Running getBoundingClientRect on a disconnected node
                                // in IE throws an error.
                                (!elem.getClientRects().length || !elem.getBoundingClientRect().width) ?
                                swap(elem, cssShow, function () {
                                    return getWidthOrHeight(elem, name, extra);
                                }) :
                                getWidthOrHeight(elem, name, extra);
                        }
                    },

                    set: function (elem, value, extra) {
                        var matches,
                            styles = extra && getStyles(elem),
                            subtract = extra && augmentWidthOrHeight(
                                elem,
                                name,
                                extra,
                                jQuery.css(elem, "boxSizing", false, styles) === "border-box",
                                styles
                            );

                        // Convert to pixels if value adjustment is needed
                        if (subtract && (matches = rcssNum.exec(value)) &&
                            (matches[3] || "px") !== "px") {

                            elem.style[name] = value;
                            value = jQuery.css(elem, name);
                        }

                        return setPositiveNumber(elem, value, subtract);
                    }
                };
            });

            jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft,
                function (elem, computed) {
                    if (computed) {
                        return (parseFloat(curCSS(elem, "marginLeft")) ||
                            elem.getBoundingClientRect().left -
                            swap(elem, { marginLeft: 0 }, function () {
                                return elem.getBoundingClientRect().left;
                            })
                        ) + "px";
                    }
                }
            );

            // These hooks are used by animate to expand properties
            jQuery.each({
                margin: "",
                padding: "",
                border: "Width"
            }, function (prefix, suffix) {
                jQuery.cssHooks[prefix + suffix] = {
                    expand: function (value) {
                        var i = 0,
                            expanded = {},

                            // Assumes a single number if not a string
                            parts = typeof value === "string" ? value.split(" ") : [value];

                        for (; i < 4; i++) {
                            expanded[prefix + cssExpand[i] + suffix] =
                                parts[i] || parts[i - 2] || parts[0];
                        }

                        return expanded;
                    }
                };

                if (!rmargin.test(prefix)) {
                    jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
                }
            });

            jQuery.fn.extend({
                css: function (name, value) {
                    return access(this, function (elem, name, value) {
                        var styles, len,
                            map = {},
                            i = 0;

                        if (Array.isArray(name)) {
                            styles = getStyles(elem);
                            len = name.length;

                            for (; i < len; i++) {
                                map[name[i]] = jQuery.css(elem, name[i], false, styles);
                            }

                            return map;
                        }

                        return value !== undefined ?
                            jQuery.style(elem, name, value) :
                            jQuery.css(elem, name);
                    }, name, value, arguments.length > 1);
                }
            });


            function Tween(elem, options, prop, end, easing) {
                return new Tween.prototype.init(elem, options, prop, end, easing);
            }
            jQuery.Tween = Tween;

            Tween.prototype = {
                constructor: Tween,
                init: function (elem, options, prop, end, easing, unit) {
                    this.elem = elem;
                    this.prop = prop;
                    this.easing = easing || jQuery.easing._default;
                    this.options = options;
                    this.start = this.now = this.cur();
                    this.end = end;
                    this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
                },
                cur: function () {
                    var hooks = Tween.propHooks[this.prop];

                    return hooks && hooks.get ?
                        hooks.get(this) :
                        Tween.propHooks._default.get(this);
                },
                run: function (percent) {
                    var eased,
                        hooks = Tween.propHooks[this.prop];

                    if (this.options.duration) {
                        this.pos = eased = jQuery.easing[this.easing](
                            percent, this.options.duration * percent, 0, 1, this.options.duration
                        );
                    } else {
                        this.pos = eased = percent;
                    }
                    this.now = (this.end - this.start) * eased + this.start;

                    if (this.options.step) {
                        this.options.step.call(this.elem, this.now, this);
                    }

                    if (hooks && hooks.set) {
                        hooks.set(this);
                    } else {
                        Tween.propHooks._default.set(this);
                    }
                    return this;
                }
            };

            Tween.prototype.init.prototype = Tween.prototype;

            Tween.propHooks = {
                _default: {
                    get: function (tween) {
                        var result;

                        // Use a property on the element directly when it is not a DOM element,
                        // or when there is no matching style property that exists.
                        if (tween.elem.nodeType !== 1 ||
                            tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
                            return tween.elem[tween.prop];
                        }

                        // Passing an empty string as a 3rd parameter to .css will automatically
                        // attempt a parseFloat and fallback to a string if the parse fails.
                        // Simple values such as "10px" are parsed to Float;
                        // complex values such as "rotate(1rad)" are returned as-is.
                        result = jQuery.css(tween.elem, tween.prop, "");

                        // Empty strings, null, undefined and "auto" are converted to 0.
                        return !result || result === "auto" ? 0 : result;
                    },
                    set: function (tween) {

                        // Use step hook for back compat.
                        // Use cssHook if its there.
                        // Use .style if available and use plain properties where available.
                        if (jQuery.fx.step[tween.prop]) {
                            jQuery.fx.step[tween.prop](tween);
                        } else if (tween.elem.nodeType === 1 &&
                            (tween.elem.style[jQuery.cssProps[tween.prop]] != null ||
                                jQuery.cssHooks[tween.prop])) {
                            jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
                        } else {
                            tween.elem[tween.prop] = tween.now;
                        }
                    }
                }
            };

            // Support: IE <=9 only
            // Panic based approach to setting things on disconnected nodes
            Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
                set: function (tween) {
                    if (tween.elem.nodeType && tween.elem.parentNode) {
                        tween.elem[tween.prop] = tween.now;
                    }
                }
            };

            jQuery.easing = {
                linear: function (p) {
                    return p;
                },
                swing: function (p) {
                    return 0.5 - Math.cos(p * Math.PI) / 2;
                },
                _default: "swing"
            };

            jQuery.fx = Tween.prototype.init;

            // Back compat <1.8 extension point
            jQuery.fx.step = {};




            var
                fxNow, inProgress,
                rfxtypes = /^(?:toggle|show|hide)$/,
                rrun = /queueHooks$/;

            function schedule() {
                if (inProgress) {
                    if (document.hidden === false && window.requestAnimationFrame) {
                        window.requestAnimationFrame(schedule);
                    } else {
                        window.setTimeout(schedule, jQuery.fx.interval);
                    }

                    jQuery.fx.tick();
                }
            }

            // Animations created synchronously will run synchronously
            function createFxNow() {
                window.setTimeout(function () {
                    fxNow = undefined;
                });
                return (fxNow = jQuery.now());
            }

            // Generate parameters to create a standard animation
            function genFx(type, includeWidth) {
                var which,
                    i = 0,
                    attrs = { height: type };

                // If we include width, step value is 1 to do all cssExpand values,
                // otherwise step value is 2 to skip over Left and Right
                includeWidth = includeWidth ? 1 : 0;
                for (; i < 4; i += 2 - includeWidth) {
                    which = cssExpand[i];
                    attrs["margin" + which] = attrs["padding" + which] = type;
                }

                if (includeWidth) {
                    attrs.opacity = attrs.width = type;
                }

                return attrs;
            }

            function createTween(value, prop, animation) {
                var tween,
                    collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]),
                    index = 0,
                    length = collection.length;
                for (; index < length; index++) {
                    if ((tween = collection[index].call(animation, prop, value))) {

                        // We're done with this property
                        return tween;
                    }
                }
            }

            function defaultPrefilter(elem, props, opts) {
                var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
                    isBox = "width" in props || "height" in props,
                    anim = this,
                    orig = {},
                    style = elem.style,
                    hidden = elem.nodeType && isHiddenWithinTree(elem),
                    dataShow = dataPriv.get(elem, "fxshow");

                // Queue-skipping animations hijack the fx hooks
                if (!opts.queue) {
                    hooks = jQuery._queueHooks(elem, "fx");
                    if (hooks.unqueued == null) {
                        hooks.unqueued = 0;
                        oldfire = hooks.empty.fire;
                        hooks.empty.fire = function () {
                            if (!hooks.unqueued) {
                                oldfire();
                            }
                        };
                    }
                    hooks.unqueued++;

                    anim.always(function () {

                        // Ensure the complete handler is called before this completes
                        anim.always(function () {
                            hooks.unqueued--;
                            if (!jQuery.queue(elem, "fx").length) {
                                hooks.empty.fire();
                            }
                        });
                    });
                }

                // Detect show/hide animations
                for (prop in props) {
                    value = props[prop];
                    if (rfxtypes.test(value)) {
                        delete props[prop];
                        toggle = toggle || value === "toggle";
                        if (value === (hidden ? "hide" : "show")) {

                            // Pretend to be hidden if this is a "show" and
                            // there is still data from a stopped show/hide
                            if (value === "show" && dataShow && dataShow[prop] !== undefined) {
                                hidden = true;

                                // Ignore all other no-op show/hide data
                            } else {
                                continue;
                            }
                        }
                        orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
                    }
                }

                // Bail out if this is a no-op like .hide().hide()
                propTween = !jQuery.isEmptyObject(props);
                if (!propTween && jQuery.isEmptyObject(orig)) {
                    return;
                }

                // Restrict "overflow" and "display" styles during box animations
                if (isBox && elem.nodeType === 1) {

                    // Support: IE <=9 - 11, Edge 12 - 13
                    // Record all 3 overflow attributes because IE does not infer the shorthand
                    // from identically-valued overflowX and overflowY
                    opts.overflow = [style.overflow, style.overflowX, style.overflowY];

                    // Identify a display type, preferring old show/hide data over the CSS cascade
                    restoreDisplay = dataShow && dataShow.display;
                    if (restoreDisplay == null) {
                        restoreDisplay = dataPriv.get(elem, "display");
                    }
                    display = jQuery.css(elem, "display");
                    if (display === "none") {
                        if (restoreDisplay) {
                            display = restoreDisplay;
                        } else {

                            // Get nonempty value(s) by temporarily forcing visibility
                            showHide([elem], true);
                            restoreDisplay = elem.style.display || restoreDisplay;
                            display = jQuery.css(elem, "display");
                            showHide([elem]);
                        }
                    }

                    // Animate inline elements as inline-block
                    if (display === "inline" || display === "inline-block" && restoreDisplay != null) {
                        if (jQuery.css(elem, "float") === "none") {

                            // Restore the original display value at the end of pure show/hide animations
                            if (!propTween) {
                                anim.done(function () {
                                    style.display = restoreDisplay;
                                });
                                if (restoreDisplay == null) {
                                    display = style.display;
                                    restoreDisplay = display === "none" ? "" : display;
                                }
                            }
                            style.display = "inline-block";
                        }
                    }
                }

                if (opts.overflow) {
                    style.overflow = "hidden";
                    anim.always(function () {
                        style.overflow = opts.overflow[0];
                        style.overflowX = opts.overflow[1];
                        style.overflowY = opts.overflow[2];
                    });
                }

                // Implement show/hide animations
                propTween = false;
                for (prop in orig) {

                    // General show/hide setup for this element animation
                    if (!propTween) {
                        if (dataShow) {
                            if ("hidden" in dataShow) {
                                hidden = dataShow.hidden;
                            }
                        } else {
                            dataShow = dataPriv.access(elem, "fxshow", { display: restoreDisplay });
                        }

                        // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
                        if (toggle) {
                            dataShow.hidden = !hidden;
                        }

                        // Show elements before animating them
                        if (hidden) {
                            showHide([elem], true);
                        }

                        /* eslint-disable no-loop-func */

                        anim.done(function () {

                            /* eslint-enable no-loop-func */

                            // The final step of a "hide" animation is actually hiding the element
                            if (!hidden) {
                                showHide([elem]);
                            }
                            dataPriv.remove(elem, "fxshow");
                            for (prop in orig) {
                                jQuery.style(elem, prop, orig[prop]);
                            }
                        });
                    }

                    // Per-property setup
                    propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
                    if (!(prop in dataShow)) {
                        dataShow[prop] = propTween.start;
                        if (hidden) {
                            propTween.end = propTween.start;
                            propTween.start = 0;
                        }
                    }
                }
            }

            function propFilter(props, specialEasing) {
                var index, name, easing, value, hooks;

                // camelCase, specialEasing and expand cssHook pass
                for (index in props) {
                    name = jQuery.camelCase(index);
                    easing = specialEasing[name];
                    value = props[index];
                    if (Array.isArray(value)) {
                        easing = value[1];
                        value = props[index] = value[0];
                    }

                    if (index !== name) {
                        props[name] = value;
                        delete props[index];
                    }

                    hooks = jQuery.cssHooks[name];
                    if (hooks && "expand" in hooks) {
                        value = hooks.expand(value);
                        delete props[name];

                        // Not quite $.extend, this won't overwrite existing keys.
                        // Reusing 'index' because we have the correct "name"
                        for (index in value) {
                            if (!(index in props)) {
                                props[index] = value[index];
                                specialEasing[index] = easing;
                            }
                        }
                    } else {
                        specialEasing[name] = easing;
                    }
                }
            }

            function Animation(elem, properties, options) {
                var result,
                    stopped,
                    index = 0,
                    length = Animation.prefilters.length,
                    deferred = jQuery.Deferred().always(function () {

                        // Don't match elem in the :animated selector
                        delete tick.elem;
                    }),
                    tick = function () {
                        if (stopped) {
                            return false;
                        }
                        var currentTime = fxNow || createFxNow(),
                            remaining = Math.max(0, animation.startTime + animation.duration - currentTime),

                            // Support: Android 2.3 only
                            // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
                            temp = remaining / animation.duration || 0,
                            percent = 1 - temp,
                            index = 0,
                            length = animation.tweens.length;

                        for (; index < length; index++) {
                            animation.tweens[index].run(percent);
                        }

                        deferred.notifyWith(elem, [animation, percent, remaining]);

                        // If there's more to do, yield
                        if (percent < 1 && length) {
                            return remaining;
                        }

                        // If this was an empty animation, synthesize a final progress notification
                        if (!length) {
                            deferred.notifyWith(elem, [animation, 1, 0]);
                        }

                        // Resolve the animation and report its conclusion
                        deferred.resolveWith(elem, [animation]);
                        return false;
                    },
                    animation = deferred.promise({
                        elem: elem,
                        props: jQuery.extend({}, properties),
                        opts: jQuery.extend(true, {
                            specialEasing: {},
                            easing: jQuery.easing._default
                        }, options),
                        originalProperties: properties,
                        originalOptions: options,
                        startTime: fxNow || createFxNow(),
                        duration: options.duration,
                        tweens: [],
                        createTween: function (prop, end) {
                            var tween = jQuery.Tween(elem, animation.opts, prop, end,
                                animation.opts.specialEasing[prop] || animation.opts.easing);
                            animation.tweens.push(tween);
                            return tween;
                        },
                        stop: function (gotoEnd) {
                            var index = 0,

                                // If we are going to the end, we want to run all the tweens
                                // otherwise we skip this part
                                length = gotoEnd ? animation.tweens.length : 0;
                            if (stopped) {
                                return this;
                            }
                            stopped = true;
                            for (; index < length; index++) {
                                animation.tweens[index].run(1);
                            }

                            // Resolve when we played the last frame; otherwise, reject
                            if (gotoEnd) {
                                deferred.notifyWith(elem, [animation, 1, 0]);
                                deferred.resolveWith(elem, [animation, gotoEnd]);
                            } else {
                                deferred.rejectWith(elem, [animation, gotoEnd]);
                            }
                            return this;
                        }
                    }),
                    props = animation.props;

                propFilter(props, animation.opts.specialEasing);

                for (; index < length; index++) {
                    result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
                    if (result) {
                        if (jQuery.isFunction(result.stop)) {
                            jQuery._queueHooks(animation.elem, animation.opts.queue).stop =
                                jQuery.proxy(result.stop, result);
                        }
                        return result;
                    }
                }

                jQuery.map(props, createTween, animation);

                if (jQuery.isFunction(animation.opts.start)) {
                    animation.opts.start.call(elem, animation);
                }

                // Attach callbacks from options
                animation
                    .progress(animation.opts.progress)
                    .done(animation.opts.done, animation.opts.complete)
                    .fail(animation.opts.fail)
                    .always(animation.opts.always);

                jQuery.fx.timer(
                    jQuery.extend(tick, {
                        elem: elem,
                        anim: animation,
                        queue: animation.opts.queue
                    })
                );

                return animation;
            }

            jQuery.Animation = jQuery.extend(Animation, {

                tweeners: {
                    "*": [function (prop, value) {
                        var tween = this.createTween(prop, value);
                        adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
                        return tween;
                    }]
                },

                tweener: function (props, callback) {
                    if (jQuery.isFunction(props)) {
                        callback = props;
                        props = ["*"];
                    } else {
                        props = props.match(rnothtmlwhite);
                    }

                    var prop,
                        index = 0,
                        length = props.length;

                    for (; index < length; index++) {
                        prop = props[index];
                        Animation.tweeners[prop] = Animation.tweeners[prop] || [];
                        Animation.tweeners[prop].unshift(callback);
                    }
                },

                prefilters: [defaultPrefilter],

                prefilter: function (callback, prepend) {
                    if (prepend) {
                        Animation.prefilters.unshift(callback);
                    } else {
                        Animation.prefilters.push(callback);
                    }
                }
            });

            jQuery.speed = function (speed, easing, fn) {
                var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
                    complete: fn || !fn && easing ||
                        jQuery.isFunction(speed) && speed,
                    duration: speed,
                    easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
                };

                // Go to the end state if fx are off
                if (jQuery.fx.off) {
                    opt.duration = 0;

                } else {
                    if (typeof opt.duration !== "number") {
                        if (opt.duration in jQuery.fx.speeds) {
                            opt.duration = jQuery.fx.speeds[opt.duration];

                        } else {
                            opt.duration = jQuery.fx.speeds._default;
                        }
                    }
                }

                // Normalize opt.queue - true/undefined/null -> "fx"
                if (opt.queue == null || opt.queue === true) {
                    opt.queue = "fx";
                }

                // Queueing
                opt.old = opt.complete;

                opt.complete = function () {
                    if (jQuery.isFunction(opt.old)) {
                        opt.old.call(this);
                    }

                    if (opt.queue) {
                        jQuery.dequeue(this, opt.queue);
                    }
                };

                return opt;
            };

            jQuery.fn.extend({
                fadeTo: function (speed, to, easing, callback) {

                    // Show any hidden elements after setting opacity to 0
                    return this.filter(isHiddenWithinTree).css("opacity", 0).show()

                        // Animate to the value specified
                        .end().animate({ opacity: to }, speed, easing, callback);
                },
                animate: function (prop, speed, easing, callback) {
                    var empty = jQuery.isEmptyObject(prop),
                        optall = jQuery.speed(speed, easing, callback),
                        doAnimation = function () {

                            // Operate on a copy of prop so per-property easing won't be lost
                            var anim = Animation(this, jQuery.extend({}, prop), optall);

                            // Empty animations, or finishing resolves immediately
                            if (empty || dataPriv.get(this, "finish")) {
                                anim.stop(true);
                            }
                        };
                    doAnimation.finish = doAnimation;

                    return empty || optall.queue === false ?
                        this.each(doAnimation) :
                        this.queue(optall.queue, doAnimation);
                },
                stop: function (type, clearQueue, gotoEnd) {
                    var stopQueue = function (hooks) {
                        var stop = hooks.stop;
                        delete hooks.stop;
                        stop(gotoEnd);
                    };

                    if (typeof type !== "string") {
                        gotoEnd = clearQueue;
                        clearQueue = type;
                        type = undefined;
                    }
                    if (clearQueue && type !== false) {
                        this.queue(type || "fx", []);
                    }

                    return this.each(function () {
                        var dequeue = true,
                            index = type != null && type + "queueHooks",
                            timers = jQuery.timers,
                            data = dataPriv.get(this);

                        if (index) {
                            if (data[index] && data[index].stop) {
                                stopQueue(data[index]);
                            }
                        } else {
                            for (index in data) {
                                if (data[index] && data[index].stop && rrun.test(index)) {
                                    stopQueue(data[index]);
                                }
                            }
                        }

                        for (index = timers.length; index--;) {
                            if (timers[index].elem === this &&
                                (type == null || timers[index].queue === type)) {

                                timers[index].anim.stop(gotoEnd);
                                dequeue = false;
                                timers.splice(index, 1);
                            }
                        }

                        // Start the next in the queue if the last step wasn't forced.
                        // Timers currently will call their complete callbacks, which
                        // will dequeue but only if they were gotoEnd.
                        if (dequeue || !gotoEnd) {
                            jQuery.dequeue(this, type);
                        }
                    });
                },
                finish: function (type) {
                    if (type !== false) {
                        type = type || "fx";
                    }
                    return this.each(function () {
                        var index,
                            data = dataPriv.get(this),
                            queue = data[type + "queue"],
                            hooks = data[type + "queueHooks"],
                            timers = jQuery.timers,
                            length = queue ? queue.length : 0;

                        // Enable finishing flag on private data
                        data.finish = true;

                        // Empty the queue first
                        jQuery.queue(this, type, []);

                        if (hooks && hooks.stop) {
                            hooks.stop.call(this, true);
                        }

                        // Look for any active animations, and finish them
                        for (index = timers.length; index--;) {
                            if (timers[index].elem === this && timers[index].queue === type) {
                                timers[index].anim.stop(true);
                                timers.splice(index, 1);
                            }
                        }

                        // Look for any animations in the old queue and finish them
                        for (index = 0; index < length; index++) {
                            if (queue[index] && queue[index].finish) {
                                queue[index].finish.call(this);
                            }
                        }

                        // Turn off finishing flag
                        delete data.finish;
                    });
                }
            });

            jQuery.each(["toggle", "show", "hide"], function (i, name) {
                var cssFn = jQuery.fn[name];
                jQuery.fn[name] = function (speed, easing, callback) {
                    return speed == null || typeof speed === "boolean" ?
                        cssFn.apply(this, arguments) :
                        this.animate(genFx(name, true), speed, easing, callback);
                };
            });

            // Generate shortcuts for custom animations
            jQuery.each({
                slideDown: genFx("show"),
                slideUp: genFx("hide"),
                slideToggle: genFx("toggle"),
                fadeIn: { opacity: "show" },
                fadeOut: { opacity: "hide" },
                fadeToggle: { opacity: "toggle" }
            }, function (name, props) {
                jQuery.fn[name] = function (speed, easing, callback) {
                    return this.animate(props, speed, easing, callback);
                };
            });

            jQuery.timers = [];
            jQuery.fx.tick = function () {
                var timer,
                    i = 0,
                    timers = jQuery.timers;

                fxNow = jQuery.now();

                for (; i < timers.length; i++) {
                    timer = timers[i];

                    // Run the timer and safely remove it when done (allowing for external removal)
                    if (!timer() && timers[i] === timer) {
                        timers.splice(i--, 1);
                    }
                }

                if (!timers.length) {
                    jQuery.fx.stop();
                }
                fxNow = undefined;
            };

            jQuery.fx.timer = function (timer) {
                jQuery.timers.push(timer);
                jQuery.fx.start();
            };

            jQuery.fx.interval = 13;
            jQuery.fx.start = function () {
                if (inProgress) {
                    return;
                }

                inProgress = true;
                schedule();
            };

            jQuery.fx.stop = function () {
                inProgress = null;
            };

            jQuery.fx.speeds = {
                slow: 600,
                fast: 200,

                // Default speed
                _default: 400
            };


            // Based off of the plugin by Clint Helfers, with permission.
            // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
            jQuery.fn.delay = function (time, type) {
                time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
                type = type || "fx";

                return this.queue(type, function (next, hooks) {
                    var timeout = window.setTimeout(next, time);
                    hooks.stop = function () {
                        window.clearTimeout(timeout);
                    };
                });
            };


            (function () {
                var input = document.createElement("input"),
                    select = document.createElement("select"),
                    opt = select.appendChild(document.createElement("option"));

                input.type = "checkbox";

                // Support: Android <=4.3 only
                // Default value for a checkbox should be "on"
                support.checkOn = input.value !== "";

                // Support: IE <=11 only
                // Must access selectedIndex to make default options select
                support.optSelected = opt.selected;

                // Support: IE <=11 only
                // An input loses its value after becoming a radio
                input = document.createElement("input");
                input.value = "t";
                input.type = "radio";
                support.radioValue = input.value === "t";
            })();


            var boolHook,
                attrHandle = jQuery.expr.attrHandle;

            jQuery.fn.extend({
                attr: function (name, value) {
                    return access(this, jQuery.attr, name, value, arguments.length > 1);
                },

                removeAttr: function (name) {
                    return this.each(function () {
                        jQuery.removeAttr(this, name);
                    });
                }
            });

            jQuery.extend({
                attr: function (elem, name, value) {
                    var ret, hooks,
                        nType = elem.nodeType;

                    // Don't get/set attributes on text, comment and attribute nodes
                    if (nType === 3 || nType === 8 || nType === 2) {
                        return;
                    }

                    // Fallback to prop when attributes are not supported
                    if (typeof elem.getAttribute === "undefined") {
                        return jQuery.prop(elem, name, value);
                    }

                    // Attribute hooks are determined by the lowercase version
                    // Grab necessary hook if one is defined
                    if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
                        hooks = jQuery.attrHooks[name.toLowerCase()] ||
                            (jQuery.expr.match.bool.test(name) ? boolHook : undefined);
                    }

                    if (value !== undefined) {
                        if (value === null) {
                            jQuery.removeAttr(elem, name);
                            return;
                        }

                        if (hooks && "set" in hooks &&
                            (ret = hooks.set(elem, value, name)) !== undefined) {
                            return ret;
                        }

                        elem.setAttribute(name, value + "");
                        return value;
                    }

                    if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
                        return ret;
                    }

                    ret = jQuery.find.attr(elem, name);

                    // Non-existent attributes return null, we normalize to undefined
                    return ret == null ? undefined : ret;
                },

                attrHooks: {
                    type: {
                        set: function (elem, value) {
                            if (!support.radioValue && value === "radio" &&
                                nodeName(elem, "input")) {
                                var val = elem.value;
                                elem.setAttribute("type", value);
                                if (val) {
                                    elem.value = val;
                                }
                                return value;
                            }
                        }
                    }
                },

                removeAttr: function (elem, value) {
                    var name,
                        i = 0,

                        // Attribute names can contain non-HTML whitespace characters
                        // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
                        attrNames = value && value.match(rnothtmlwhite);

                    if (attrNames && elem.nodeType === 1) {
                        while ((name = attrNames[i++])) {
                            elem.removeAttribute(name);
                        }
                    }
                }
            });

            // Hooks for boolean attributes
            boolHook = {
                set: function (elem, value, name) {
                    if (value === false) {

                        // Remove boolean attributes when set to false
                        jQuery.removeAttr(elem, name);
                    } else {
                        elem.setAttribute(name, name);
                    }
                    return name;
                }
            };

            jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (i, name) {
                var getter = attrHandle[name] || jQuery.find.attr;

                attrHandle[name] = function (elem, name, isXML) {
                    var ret, handle,
                        lowercaseName = name.toLowerCase();

                    if (!isXML) {

                        // Avoid an infinite loop by temporarily removing this function from the getter
                        handle = attrHandle[lowercaseName];
                        attrHandle[lowercaseName] = ret;
                        ret = getter(elem, name, isXML) != null ?
                            lowercaseName :
                            null;
                        attrHandle[lowercaseName] = handle;
                    }
                    return ret;
                };
            });




            var rfocusable = /^(?:input|select|textarea|button)$/i,
                rclickable = /^(?:a|area)$/i;

            jQuery.fn.extend({
                prop: function (name, value) {
                    return access(this, jQuery.prop, name, value, arguments.length > 1);
                },

                removeProp: function (name) {
                    return this.each(function () {
                        delete this[jQuery.propFix[name] || name];
                    });
                }
            });

            jQuery.extend({
                prop: function (elem, name, value) {
                    var ret, hooks,
                        nType = elem.nodeType;

                    // Don't get/set properties on text, comment and attribute nodes
                    if (nType === 3 || nType === 8 || nType === 2) {
                        return;
                    }

                    if (nType !== 1 || !jQuery.isXMLDoc(elem)) {

                        // Fix name and attach hooks
                        name = jQuery.propFix[name] || name;
                        hooks = jQuery.propHooks[name];
                    }

                    if (value !== undefined) {
                        if (hooks && "set" in hooks &&
                            (ret = hooks.set(elem, value, name)) !== undefined) {
                            return ret;
                        }

                        return (elem[name] = value);
                    }

                    if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
                        return ret;
                    }

                    return elem[name];
                },

                propHooks: {
                    tabIndex: {
                        get: function (elem) {

                            // Support: IE <=9 - 11 only
                            // elem.tabIndex doesn't always return the
                            // correct value when it hasn't been explicitly set
                            // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
                            // Use proper attribute retrieval(#12072)
                            var tabindex = jQuery.find.attr(elem, "tabindex");

                            if (tabindex) {
                                return parseInt(tabindex, 10);
                            }

                            if (
                                rfocusable.test(elem.nodeName) ||
                                rclickable.test(elem.nodeName) &&
                                elem.href
                            ) {
                                return 0;
                            }

                            return -1;
                        }
                    }
                },

                propFix: {
                    "for": "htmlFor",
                    "class": "className"
                }
            });

            // Support: IE <=11 only
            // Accessing the selectedIndex property
            // forces the browser to respect setting selected
            // on the option
            // The getter ensures a default option is selected
            // when in an optgroup
            // eslint rule "no-unused-expressions" is disabled for this code
            // since it considers such accessions noop
            if (!support.optSelected) {
                jQuery.propHooks.selected = {
                    get: function (elem) {

                        /* eslint no-unused-expressions: "off" */

                        var parent = elem.parentNode;
                        if (parent && parent.parentNode) {
                            parent.parentNode.selectedIndex;
                        }
                        return null;
                    },
                    set: function (elem) {

                        /* eslint no-unused-expressions: "off" */

                        var parent = elem.parentNode;
                        if (parent) {
                            parent.selectedIndex;

                            if (parent.parentNode) {
                                parent.parentNode.selectedIndex;
                            }
                        }
                    }
                };
            }

            jQuery.each([
                "tabIndex",
                "readOnly",
                "maxLength",
                "cellSpacing",
                "cellPadding",
                "rowSpan",
                "colSpan",
                "useMap",
                "frameBorder",
                "contentEditable"
            ], function () {
                jQuery.propFix[this.toLowerCase()] = this;
            });




            // Strip and collapse whitespace according to HTML spec
            // https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
            function stripAndCollapse(value) {
                var tokens = value.match(rnothtmlwhite) || [];
                return tokens.join(" ");
            }


            function getClass(elem) {
                return elem.getAttribute && elem.getAttribute("class") || "";
            }

            jQuery.fn.extend({
                addClass: function (value) {
                    var classes, elem, cur, curValue, clazz, j, finalValue,
                        i = 0;

                    if (jQuery.isFunction(value)) {
                        return this.each(function (j) {
                            jQuery(this).addClass(value.call(this, j, getClass(this)));
                        });
                    }

                    if (typeof value === "string" && value) {
                        classes = value.match(rnothtmlwhite) || [];

                        while ((elem = this[i++])) {
                            curValue = getClass(elem);
                            cur = elem.nodeType === 1 && (" " + stripAndCollapse(curValue) + " ");

                            if (cur) {
                                j = 0;
                                while ((clazz = classes[j++])) {
                                    if (cur.indexOf(" " + clazz + " ") < 0) {
                                        cur += clazz + " ";
                                    }
                                }

                                // Only assign if different to avoid unneeded rendering.
                                finalValue = stripAndCollapse(cur);
                                if (curValue !== finalValue) {
                                    elem.setAttribute("class", finalValue);
                                }
                            }
                        }
                    }

                    return this;
                },

                removeClass: function (value) {
                    var classes, elem, cur, curValue, clazz, j, finalValue,
                        i = 0;

                    if (jQuery.isFunction(value)) {
                        return this.each(function (j) {
                            jQuery(this).removeClass(value.call(this, j, getClass(this)));
                        });
                    }

                    if (!arguments.length) {
                        return this.attr("class", "");
                    }

                    if (typeof value === "string" && value) {
                        classes = value.match(rnothtmlwhite) || [];

                        while ((elem = this[i++])) {
                            curValue = getClass(elem);

                            // This expression is here for better compressibility (see addClass)
                            cur = elem.nodeType === 1 && (" " + stripAndCollapse(curValue) + " ");

                            if (cur) {
                                j = 0;
                                while ((clazz = classes[j++])) {

                                    // Remove *all* instances
                                    while (cur.indexOf(" " + clazz + " ") > -1) {
                                        cur = cur.replace(" " + clazz + " ", " ");
                                    }
                                }

                                // Only assign if different to avoid unneeded rendering.
                                finalValue = stripAndCollapse(cur);
                                if (curValue !== finalValue) {
                                    elem.setAttribute("class", finalValue);
                                }
                            }
                        }
                    }

                    return this;
                },

                toggleClass: function (value, stateVal) {
                    var type = typeof value;

                    if (typeof stateVal === "boolean" && type === "string") {
                        return stateVal ? this.addClass(value) : this.removeClass(value);
                    }

                    if (jQuery.isFunction(value)) {
                        return this.each(function (i) {
                            jQuery(this).toggleClass(
                                value.call(this, i, getClass(this), stateVal),
                                stateVal
                            );
                        });
                    }

                    return this.each(function () {
                        var className, i, self, classNames;

                        if (type === "string") {

                            // Toggle individual class names
                            i = 0;
                            self = jQuery(this);
                            classNames = value.match(rnothtmlwhite) || [];

                            while ((className = classNames[i++])) {

                                // Check each className given, space separated list
                                if (self.hasClass(className)) {
                                    self.removeClass(className);
                                } else {
                                    self.addClass(className);
                                }
                            }

                            // Toggle whole class name
                        } else if (value === undefined || type === "boolean") {
                            className = getClass(this);
                            if (className) {

                                // Store className if set
                                dataPriv.set(this, "__className__", className);
                            }

                            // If the element has a class name or if we're passed `false`,
                            // then remove the whole classname (if there was one, the above saved it).
                            // Otherwise bring back whatever was previously saved (if anything),
                            // falling back to the empty string if nothing was stored.
                            if (this.setAttribute) {
                                this.setAttribute("class",
                                    className || value === false ?
                                        "" :
                                        dataPriv.get(this, "__className__") || ""
                                );
                            }
                        }
                    });
                },

                hasClass: function (selector) {
                    var className, elem,
                        i = 0;

                    className = " " + selector + " ";
                    while ((elem = this[i++])) {
                        if (elem.nodeType === 1 &&
                            (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) {
                            return true;
                        }
                    }

                    return false;
                }
            });




            var rreturn = /\r/g;

            jQuery.fn.extend({
                val: function (value) {
                    var hooks, ret, isFunction,
                        elem = this[0];

                    if (!arguments.length) {
                        if (elem) {
                            hooks = jQuery.valHooks[elem.type] ||
                                jQuery.valHooks[elem.nodeName.toLowerCase()];

                            if (hooks &&
                                "get" in hooks &&
                                (ret = hooks.get(elem, "value")) !== undefined
                            ) {
                                return ret;
                            }

                            ret = elem.value;

                            // Handle most common string cases
                            if (typeof ret === "string") {
                                return ret.replace(rreturn, "");
                            }

                            // Handle cases where value is null/undef or number
                            return ret == null ? "" : ret;
                        }

                        return;
                    }

                    isFunction = jQuery.isFunction(value);

                    return this.each(function (i) {
                        var val;

                        if (this.nodeType !== 1) {
                            return;
                        }

                        if (isFunction) {
                            val = value.call(this, i, jQuery(this).val());
                        } else {
                            val = value;
                        }

                        // Treat null/undefined as ""; convert numbers to string
                        if (val == null) {
                            val = "";

                        } else if (typeof val === "number") {
                            val += "";

                        } else if (Array.isArray(val)) {
                            val = jQuery.map(val, function (value) {
                                return value == null ? "" : value + "";
                            });
                        }

                        hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];

                        // If set returns undefined, fall back to normal setting
                        if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
                            this.value = val;
                        }
                    });
                }
            });

            jQuery.extend({
                valHooks: {
                    option: {
                        get: function (elem) {

                            var val = jQuery.find.attr(elem, "value");
                            return val != null ?
                                val :

                                // Support: IE <=10 - 11 only
                                // option.text throws exceptions (#14686, #14858)
                                // Strip and collapse whitespace
                                // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
                                stripAndCollapse(jQuery.text(elem));
                        }
                    },
                    select: {
                        get: function (elem) {
                            var value, option, i,
                                options = elem.options,
                                index = elem.selectedIndex,
                                one = elem.type === "select-one",
                                values = one ? null : [],
                                max = one ? index + 1 : options.length;

                            if (index < 0) {
                                i = max;

                            } else {
                                i = one ? index : 0;
                            }

                            // Loop through all the selected options
                            for (; i < max; i++) {
                                option = options[i];

                                // Support: IE <=9 only
                                // IE8-9 doesn't update selected after form reset (#2551)
                                if ((option.selected || i === index) &&

                                    // Don't return options that are disabled or in a disabled optgroup
                                    !option.disabled &&
                                    (!option.parentNode.disabled ||
                                        !nodeName(option.parentNode, "optgroup"))) {

                                    // Get the specific value for the option
                                    value = jQuery(option).val();

                                    // We don't need an array for one selects
                                    if (one) {
                                        return value;
                                    }

                                    // Multi-Selects return an array
                                    values.push(value);
                                }
                            }

                            return values;
                        },

                        set: function (elem, value) {
                            var optionSet, option,
                                options = elem.options,
                                values = jQuery.makeArray(value),
                                i = options.length;

                            while (i--) {
                                option = options[i];

                                /* eslint-disable no-cond-assign */

                                if (option.selected =
                                    jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1
                                ) {
                                    optionSet = true;
                                }

                                /* eslint-enable no-cond-assign */
                            }

                            // Force browsers to behave consistently when non-matching value is set
                            if (!optionSet) {
                                elem.selectedIndex = -1;
                            }
                            return values;
                        }
                    }
                }
            });

            // Radios and checkboxes getter/setter
            jQuery.each(["radio", "checkbox"], function () {
                jQuery.valHooks[this] = {
                    set: function (elem, value) {
                        if (Array.isArray(value)) {
                            return (elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1);
                        }
                    }
                };
                if (!support.checkOn) {
                    jQuery.valHooks[this].get = function (elem) {
                        return elem.getAttribute("value") === null ? "on" : elem.value;
                    };
                }
            });




            // Return jQuery for attributes-only inclusion


            var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;

            jQuery.extend(jQuery.event, {

                trigger: function (event, data, elem, onlyHandlers) {

                    var i, cur, tmp, bubbleType, ontype, handle, special,
                        eventPath = [elem || document],
                        type = hasOwn.call(event, "type") ? event.type : event,
                        namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];

                    cur = tmp = elem = elem || document;

                    // Don't do events on text and comment nodes
                    if (elem.nodeType === 3 || elem.nodeType === 8) {
                        return;
                    }

                    // focus/blur morphs to focusin/out; ensure we're not firing them right now
                    if (rfocusMorph.test(type + jQuery.event.triggered)) {
                        return;
                    }

                    if (type.indexOf(".") > -1) {

                        // Namespaced trigger; create a regexp to match event type in handle()
                        namespaces = type.split(".");
                        type = namespaces.shift();
                        namespaces.sort();
                    }
                    ontype = type.indexOf(":") < 0 && "on" + type;

                    // Caller can pass in a jQuery.Event object, Object, or just an event type string
                    event = event[jQuery.expando] ?
                        event :
                        new jQuery.Event(type, typeof event === "object" && event);

                    // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
                    event.isTrigger = onlyHandlers ? 2 : 3;
                    event.namespace = namespaces.join(".");
                    event.rnamespace = event.namespace ?
                        new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") :
                        null;

                    // Clean up the event in case it is being reused
                    event.result = undefined;
                    if (!event.target) {
                        event.target = elem;
                    }

                    // Clone any incoming data and prepend the event, creating the handler arg list
                    data = data == null ?
                        [event] :
                        jQuery.makeArray(data, [event]);

                    // Allow special events to draw outside the lines
                    special = jQuery.event.special[type] || {};
                    if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
                        return;
                    }

                    // Determine event propagation path in advance, per W3C events spec (#9951)
                    // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
                    if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {

                        bubbleType = special.delegateType || type;
                        if (!rfocusMorph.test(bubbleType + type)) {
                            cur = cur.parentNode;
                        }
                        for (; cur; cur = cur.parentNode) {
                            eventPath.push(cur);
                            tmp = cur;
                        }

                        // Only add window if we got to document (e.g., not plain obj or detached DOM)
                        if (tmp === (elem.ownerDocument || document)) {
                            eventPath.push(tmp.defaultView || tmp.parentWindow || window);
                        }
                    }

                    // Fire handlers on the event path
                    i = 0;
                    while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {

                        event.type = i > 1 ?
                            bubbleType :
                            special.bindType || type;

                        // jQuery handler
                        handle = (dataPriv.get(cur, "events") || {})[event.type] &&
                            dataPriv.get(cur, "handle");
                        if (handle) {
                            handle.apply(cur, data);
                        }

                        // Native handler
                        handle = ontype && cur[ontype];
                        if (handle && handle.apply && acceptData(cur)) {
                            event.result = handle.apply(cur, data);
                            if (event.result === false) {
                                event.preventDefault();
                            }
                        }
                    }
                    event.type = type;

                    // If nobody prevented the default action, do it now
                    if (!onlyHandlers && !event.isDefaultPrevented()) {

                        if ((!special._default ||
                            special._default.apply(eventPath.pop(), data) === false) &&
                            acceptData(elem)) {

                            // Call a native DOM method on the target with the same name as the event.
                            // Don't do default actions on window, that's where global variables be (#6170)
                            if (ontype && jQuery.isFunction(elem[type]) && !jQuery.isWindow(elem)) {

                                // Don't re-trigger an onFOO event when we call its FOO() method
                                tmp = elem[ontype];

                                if (tmp) {
                                    elem[ontype] = null;
                                }

                                // Prevent re-triggering of the same event, since we already bubbled it above
                                jQuery.event.triggered = type;
                                elem[type]();
                                jQuery.event.triggered = undefined;

                                if (tmp) {
                                    elem[ontype] = tmp;
                                }
                            }
                        }
                    }

                    return event.result;
                },

                // Piggyback on a donor event to simulate a different one
                // Used only for `focus(in | out)` events
                simulate: function (type, elem, event) {
                    var e = jQuery.extend(
                        new jQuery.Event(),
                        event,
                        {
                            type: type,
                            isSimulated: true
                        }
                    );

                    jQuery.event.trigger(e, null, elem);
                }

            });

            jQuery.fn.extend({

                trigger: function (type, data) {
                    return this.each(function () {
                        jQuery.event.trigger(type, data, this);
                    });
                },
                triggerHandler: function (type, data) {
                    var elem = this[0];
                    if (elem) {
                        return jQuery.event.trigger(type, data, elem, true);
                    }
                }
            });


            jQuery.each(("blur focus focusin focusout resize scroll click dblclick " +
                "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
                "change select submit keydown keypress keyup contextmenu").split(" "),
                function (i, name) {

                    // Handle event binding
                    jQuery.fn[name] = function (data, fn) {
                        return arguments.length > 0 ?
                            this.on(name, null, data, fn) :
                            this.trigger(name);
                    };
                });

            jQuery.fn.extend({
                hover: function (fnOver, fnOut) {
                    return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
                }
            });




            support.focusin = "onfocusin" in window;


            // Support: Firefox <=44
            // Firefox doesn't have focus(in | out) events
            // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
            //
            // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
            // focus(in | out) events fire after focus & blur events,
            // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
            // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
            if (!support.focusin) {
                jQuery.each({ focus: "focusin", blur: "focusout" }, function (orig, fix) {

                    // Attach a single capturing handler on the document while someone wants focusin/focusout
                    var handler = function (event) {
                        jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
                    };

                    jQuery.event.special[fix] = {
                        setup: function () {
                            var doc = this.ownerDocument || this,
                                attaches = dataPriv.access(doc, fix);

                            if (!attaches) {
                                doc.addEventListener(orig, handler, true);
                            }
                            dataPriv.access(doc, fix, (attaches || 0) + 1);
                        },
                        teardown: function () {
                            var doc = this.ownerDocument || this,
                                attaches = dataPriv.access(doc, fix) - 1;

                            if (!attaches) {
                                doc.removeEventListener(orig, handler, true);
                                dataPriv.remove(doc, fix);

                            } else {
                                dataPriv.access(doc, fix, attaches);
                            }
                        }
                    };
                });
            }
            var location = window.location;

            var nonce = jQuery.now();

            var rquery = (/\?/);



            // Cross-browser xml parsing
            jQuery.parseXML = function (data) {
                var xml;
                if (!data || typeof data !== "string") {
                    return null;
                }

                // Support: IE 9 - 11 only
                // IE throws on parseFromString with invalid input.
                try {
                    xml = (new window.DOMParser()).parseFromString(data, "text/xml");
                } catch (e) {
                    xml = undefined;
                }

                if (!xml || xml.getElementsByTagName("parsererror").length) {
                    jQuery.error("Invalid XML: " + data);
                }
                return xml;
            };


            var
                rbracket = /\[\]$/,
                rCRLF = /\r?\n/g,
                rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
                rsubmittable = /^(?:input|select|textarea|keygen)/i;

            function buildParams(prefix, obj, traditional, add) {
                var name;

                if (Array.isArray(obj)) {

                    // Serialize array item.
                    jQuery.each(obj, function (i, v) {
                        if (traditional || rbracket.test(prefix)) {

                            // Treat each array item as a scalar.
                            add(prefix, v);

                        } else {

                            // Item is non-scalar (array or object), encode its numeric index.
                            buildParams(
                                prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]",
                                v,
                                traditional,
                                add
                            );
                        }
                    });

                } else if (!traditional && jQuery.type(obj) === "object") {

                    // Serialize object item.
                    for (name in obj) {
                        buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
                    }

                } else {

                    // Serialize scalar item.
                    add(prefix, obj);
                }
            }

            // Serialize an array of form elements or a set of
            // key/values into a query string
            jQuery.param = function (a, traditional) {
                var prefix,
                    s = [],
                    add = function (key, valueOrFunction) {

                        // If value is a function, invoke it and use its return value
                        var value = jQuery.isFunction(valueOrFunction) ?
                            valueOrFunction() :
                            valueOrFunction;

                        s[s.length] = encodeURIComponent(key) + "=" +
                            encodeURIComponent(value == null ? "" : value);
                    };

                // If an array was passed in, assume that it is an array of form elements.
                if (Array.isArray(a) || (a.jquery && !jQuery.isPlainObject(a))) {

                    // Serialize the form elements
                    jQuery.each(a, function () {
                        add(this.name, this.value);
                    });

                } else {

                    // If traditional, encode the "old" way (the way 1.3.2 or older
                    // did it), otherwise encode params recursively.
                    for (prefix in a) {
                        buildParams(prefix, a[prefix], traditional, add);
                    }
                }

                // Return the resulting serialization
                return s.join("&");
            };

            jQuery.fn.extend({
                serialize: function () {
                    return jQuery.param(this.serializeArray());
                },
                serializeArray: function () {
                    return this.map(function () {

                        // Can add propHook for "elements" to filter or add form elements
                        var elements = jQuery.prop(this, "elements");
                        return elements ? jQuery.makeArray(elements) : this;
                    })
                        .filter(function () {
                            var type = this.type;

                            // Use .is( ":disabled" ) so that fieldset[disabled] works
                            return this.name && !jQuery(this).is(":disabled") &&
                                rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) &&
                                (this.checked || !rcheckableType.test(type));
                        })
                        .map(function (i, elem) {
                            var val = jQuery(this).val();

                            if (val == null) {
                                return null;
                            }

                            if (Array.isArray(val)) {
                                return jQuery.map(val, function (val) {
                                    return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
                                });
                            }

                            return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
                        }).get();
                }
            });


            var
                r20 = /%20/g,
                rhash = /#.*$/,
                rantiCache = /([?&])_=[^&]*/,
                rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,

                // #7653, #8125, #8152: local protocol detection
                rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
                rnoContent = /^(?:GET|HEAD)$/,
                rprotocol = /^\/\//,

                /* Prefilters
                 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
                 * 2) These are called:
                 *    - BEFORE asking for a transport
                 *    - AFTER param serialization (s.data is a string if s.processData is true)
                 * 3) key is the dataType
                 * 4) the catchall symbol "*" can be used
                 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
                 */
                prefilters = {},

                /* Transports bindings
                 * 1) key is the dataType
                 * 2) the catchall symbol "*" can be used
                 * 3) selection will start with transport dataType and THEN go to "*" if needed
                 */
                transports = {},

                // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
                allTypes = "*/".concat("*"),

                // Anchor tag for parsing the document origin
                originAnchor = document.createElement("a");
            originAnchor.href = location.href;

            // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
            function addToPrefiltersOrTransports(structure) {

                // dataTypeExpression is optional and defaults to "*"
                return function (dataTypeExpression, func) {

                    if (typeof dataTypeExpression !== "string") {
                        func = dataTypeExpression;
                        dataTypeExpression = "*";
                    }

                    var dataType,
                        i = 0,
                        dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];

                    if (jQuery.isFunction(func)) {

                        // For each dataType in the dataTypeExpression
                        while ((dataType = dataTypes[i++])) {

                            // Prepend if requested
                            if (dataType[0] === "+") {
                                dataType = dataType.slice(1) || "*";
                                (structure[dataType] = structure[dataType] || []).unshift(func);

                                // Otherwise append
                            } else {
                                (structure[dataType] = structure[dataType] || []).push(func);
                            }
                        }
                    }
                };
            }

            // Base inspection function for prefilters and transports
            function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {

                var inspected = {},
                    seekingTransport = (structure === transports);

                function inspect(dataType) {
                    var selected;
                    inspected[dataType] = true;
                    jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {
                        var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
                        if (typeof dataTypeOrTransport === "string" &&
                            !seekingTransport && !inspected[dataTypeOrTransport]) {

                            options.dataTypes.unshift(dataTypeOrTransport);
                            inspect(dataTypeOrTransport);
                            return false;
                        } else if (seekingTransport) {
                            return !(selected = dataTypeOrTransport);
                        }
                    });
                    return selected;
                }

                return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
            }

            // A special extend for ajax options
            // that takes "flat" options (not to be deep extended)
            // Fixes #9887
            function ajaxExtend(target, src) {
                var key, deep,
                    flatOptions = jQuery.ajaxSettings.flatOptions || {};

                for (key in src) {
                    if (src[key] !== undefined) {
                        (flatOptions[key] ? target : (deep || (deep = {})))[key] = src[key];
                    }
                }
                if (deep) {
                    jQuery.extend(true, target, deep);
                }

                return target;
            }

            /* Handles responses to an ajax request:
             * - finds the right dataType (mediates between content-type and expected dataType)
             * - returns the corresponding response
             */
            function ajaxHandleResponses(s, jqXHR, responses) {

                var ct, type, finalDataType, firstDataType,
                    contents = s.contents,
                    dataTypes = s.dataTypes;

                // Remove auto dataType and get content-type in the process
                while (dataTypes[0] === "*") {
                    dataTypes.shift();
                    if (ct === undefined) {
                        ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
                    }
                }

                // Check if we're dealing with a known content-type
                if (ct) {
                    for (type in contents) {
                        if (contents[type] && contents[type].test(ct)) {
                            dataTypes.unshift(type);
                            break;
                        }
                    }
                }

                // Check to see if we have a response for the expected dataType
                if (dataTypes[0] in responses) {
                    finalDataType = dataTypes[0];
                } else {

                    // Try convertible dataTypes
                    for (type in responses) {
                        if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
                            finalDataType = type;
                            break;
                        }
                        if (!firstDataType) {
                            firstDataType = type;
                        }
                    }

                    // Or just use first one
                    finalDataType = finalDataType || firstDataType;
                }

                // If we found a dataType
                // We add the dataType to the list if needed
                // and return the corresponding response
                if (finalDataType) {
                    if (finalDataType !== dataTypes[0]) {
                        dataTypes.unshift(finalDataType);
                    }
                    return responses[finalDataType];
                }
            }

            /* Chain conversions given the request and the original response
             * Also sets the responseXXX fields on the jqXHR instance
             */
            function ajaxConvert(s, response, jqXHR, isSuccess) {
                var conv2, current, conv, tmp, prev,
                    converters = {},

                    // Work with a copy of dataTypes in case we need to modify it for conversion
                    dataTypes = s.dataTypes.slice();

                // Create converters map with lowercased keys
                if (dataTypes[1]) {
                    for (conv in s.converters) {
                        converters[conv.toLowerCase()] = s.converters[conv];
                    }
                }

                current = dataTypes.shift();

                // Convert to each sequential dataType
                while (current) {

                    if (s.responseFields[current]) {
                        jqXHR[s.responseFields[current]] = response;
                    }

                    // Apply the dataFilter if provided
                    if (!prev && isSuccess && s.dataFilter) {
                        response = s.dataFilter(response, s.dataType);
                    }

                    prev = current;
                    current = dataTypes.shift();

                    if (current) {

                        // There's only work to do if current dataType is non-auto
                        if (current === "*") {

                            current = prev;

                            // Convert response if prev dataType is non-auto and differs from current
                        } else if (prev !== "*" && prev !== current) {

                            // Seek a direct converter
                            conv = converters[prev + " " + current] || converters["* " + current];

                            // If none found, seek a pair
                            if (!conv) {
                                for (conv2 in converters) {

                                    // If conv2 outputs current
                                    tmp = conv2.split(" ");
                                    if (tmp[1] === current) {

                                        // If prev can be converted to accepted input
                                        conv = converters[prev + " " + tmp[0]] ||
                                            converters["* " + tmp[0]];
                                        if (conv) {

                                            // Condense equivalence converters
                                            if (conv === true) {
                                                conv = converters[conv2];

                                                // Otherwise, insert the intermediate dataType
                                            } else if (converters[conv2] !== true) {
                                                current = tmp[0];
                                                dataTypes.unshift(tmp[1]);
                                            }
                                            break;
                                        }
                                    }
                                }
                            }

                            // Apply converter (if not an equivalence)
                            if (conv !== true) {

                                // Unless errors are allowed to bubble, catch and return them
                                if (conv && s.throws) {
                                    response = conv(response);
                                } else {
                                    try {
                                        response = conv(response);
                                    } catch (e) {
                                        return {
                                            state: "parsererror",
                                            error: conv ? e : "No conversion from " + prev + " to " + current
                                        };
                                    }
                                }
                            }
                        }
                    }
                }

                return { state: "success", data: response };
            }

            jQuery.extend({

                // Counter for holding the number of active queries
                active: 0,

                // Last-Modified header cache for next request
                lastModified: {},
                etag: {},

                ajaxSettings: {
                    url: location.href,
                    type: "GET",
                    isLocal: rlocalProtocol.test(location.protocol),
                    global: true,
                    processData: true,
                    async: true,
                    contentType: "application/x-www-form-urlencoded; charset=UTF-8",

                    /*
                    timeout: 0,
                    data: null,
                    dataType: null,
                    username: null,
                    password: null,
                    cache: null,
                    throws: false,
                    traditional: false,
                    headers: {},
                    */

                    accepts: {
                        "*": allTypes,
                        text: "text/plain",
                        html: "text/html",
                        xml: "application/xml, text/xml",
                        json: "application/json, text/javascript"
                    },

                    contents: {
                        xml: /\bxml\b/,
                        html: /\bhtml/,
                        json: /\bjson\b/
                    },

                    responseFields: {
                        xml: "responseXML",
                        text: "responseText",
                        json: "responseJSON"
                    },

                    // Data converters
                    // Keys separate source (or catchall "*") and destination types with a single space
                    converters: {

                        // Convert anything to text
                        "* text": String,

                        // Text to html (true = no transformation)
                        "text html": true,

                        // Evaluate text as a json expression
                        "text json": JSON.parse,

                        // Parse text as xml
                        "text xml": jQuery.parseXML
                    },

                    // For options that shouldn't be deep extended:
                    // you can add your own custom options here if
                    // and when you create one that shouldn't be
                    // deep extended (see ajaxExtend)
                    flatOptions: {
                        url: true,
                        context: true
                    }
                },

                // Creates a full fledged settings object into target
                // with both ajaxSettings and settings fields.
                // If target is omitted, writes into ajaxSettings.
                ajaxSetup: function (target, settings) {
                    return settings ?

                        // Building a settings object
                        ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) :

                        // Extending ajaxSettings
                        ajaxExtend(jQuery.ajaxSettings, target);
                },

                ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
                ajaxTransport: addToPrefiltersOrTransports(transports),

                // Main method
                ajax: function (url, options) {

                    // If url is an object, simulate pre-1.5 signature
                    if (typeof url === "object") {
                        options = url;
                        url = undefined;
                    }

                    // Force options to be an object
                    options = options || {};

                    var transport,

                        // URL without anti-cache param
                        cacheURL,

                        // Response headers
                        responseHeadersString,
                        responseHeaders,

                        // timeout handle
                        timeoutTimer,

                        // Url cleanup var
                        urlAnchor,

                        // Request state (becomes false upon send and true upon completion)
                        completed,

                        // To know if global events are to be dispatched
                        fireGlobals,

                        // Loop variable
                        i,

                        // uncached part of the url
                        uncached,

                        // Create the final options object
                        s = jQuery.ajaxSetup({}, options),

                        // Callbacks context
                        callbackContext = s.context || s,

                        // Context for global events is callbackContext if it is a DOM node or jQuery collection
                        globalEventContext = s.context &&
                            (callbackContext.nodeType || callbackContext.jquery) ?
                            jQuery(callbackContext) :
                            jQuery.event,

                        // Deferreds
                        deferred = jQuery.Deferred(),
                        completeDeferred = jQuery.Callbacks("once memory"),

                        // Status-dependent callbacks
                        statusCode = s.statusCode || {},

                        // Headers (they are sent all at once)
                        requestHeaders = {},
                        requestHeadersNames = {},

                        // Default abort message
                        strAbort = "canceled",

                        // Fake xhr
                        jqXHR = {
                            readyState: 0,

                            // Builds headers hashtable if needed
                            getResponseHeader: function (key) {
                                var match;
                                if (completed) {
                                    if (!responseHeaders) {
                                        responseHeaders = {};
                                        while ((match = rheaders.exec(responseHeadersString))) {
                                            responseHeaders[match[1].toLowerCase()] = match[2];
                                        }
                                    }
                                    match = responseHeaders[key.toLowerCase()];
                                }
                                return match == null ? null : match;
                            },

                            // Raw string
                            getAllResponseHeaders: function () {
                                return completed ? responseHeadersString : null;
                            },

                            // Caches the header
                            setRequestHeader: function (name, value) {
                                if (completed == null) {
                                    name = requestHeadersNames[name.toLowerCase()] =
                                        requestHeadersNames[name.toLowerCase()] || name;
                                    requestHeaders[name] = value;
                                }
                                return this;
                            },

                            // Overrides response content-type header
                            overrideMimeType: function (type) {
                                if (completed == null) {
                                    s.mimeType = type;
                                }
                                return this;
                            },

                            // Status-dependent callbacks
                            statusCode: function (map) {
                                var code;
                                if (map) {
                                    if (completed) {

                                        // Execute the appropriate callbacks
                                        jqXHR.always(map[jqXHR.status]);
                                    } else {

                                        // Lazy-add the new callbacks in a way that preserves old ones
                                        for (code in map) {
                                            statusCode[code] = [statusCode[code], map[code]];
                                        }
                                    }
                                }
                                return this;
                            },

                            // Cancel the request
                            abort: function (statusText) {
                                var finalText = statusText || strAbort;
                                if (transport) {
                                    transport.abort(finalText);
                                }
                                done(0, finalText);
                                return this;
                            }
                        };

                    // Attach deferreds
                    deferred.promise(jqXHR);

                    // Add protocol if not provided (prefilters might expect it)
                    // Handle falsy url in the settings object (#10093: consistency with old signature)
                    // We also use the url parameter if available
                    s.url = ((url || s.url || location.href) + "")
                        .replace(rprotocol, location.protocol + "//");

                    // Alias method option to type as per ticket #12004
                    s.type = options.method || options.type || s.method || s.type;

                    // Extract dataTypes list
                    s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""];

                    // A cross-domain request is in order when the origin doesn't match the current origin.
                    if (s.crossDomain == null) {
                        urlAnchor = document.createElement("a");

                        // Support: IE <=8 - 11, Edge 12 - 13
                        // IE throws exception on accessing the href property if url is malformed,
                        // e.g. http://example.com:80x/
                        try {
                            urlAnchor.href = s.url;

                            // Support: IE <=8 - 11 only
                            // Anchor's host property isn't correctly set when s.url is relative
                            urlAnchor.href = urlAnchor.href;
                            s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
                                urlAnchor.protocol + "//" + urlAnchor.host;
                        } catch (e) {

                            // If there is an error parsing the URL, assume it is crossDomain,
                            // it can be rejected by the transport if it is invalid
                            s.crossDomain = true;
                        }
                    }

                    // Convert data if not already a string
                    if (s.data && s.processData && typeof s.data !== "string") {
                        s.data = jQuery.param(s.data, s.traditional);
                    }

                    // Apply prefilters
                    inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);

                    // If request was aborted inside a prefilter, stop there
                    if (completed) {
                        return jqXHR;
                    }

                    // We can fire global events as of now if asked to
                    // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
                    fireGlobals = jQuery.event && s.global;

                    // Watch for a new set of requests
                    if (fireGlobals && jQuery.active++ === 0) {
                        jQuery.event.trigger("ajaxStart");
                    }

                    // Uppercase the type
                    s.type = s.type.toUpperCase();

                    // Determine if request has content
                    s.hasContent = !rnoContent.test(s.type);

                    // Save the URL in case we're toying with the If-Modified-Since
                    // and/or If-None-Match header later on
                    // Remove hash to simplify url manipulation
                    cacheURL = s.url.replace(rhash, "");

                    // More options handling for requests with no content
                    if (!s.hasContent) {

                        // Remember the hash so we can put it back
                        uncached = s.url.slice(cacheURL.length);

                        // If data is available, append data to url
                        if (s.data) {
                            cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data;

                            // #9682: remove data so that it's not used in an eventual retry
                            delete s.data;
                        }

                        // Add or update anti-cache param if needed
                        if (s.cache === false) {
                            cacheURL = cacheURL.replace(rantiCache, "$1");
                            uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + (nonce++) + uncached;
                        }

                        // Put hash and anti-cache on the URL that will be requested (gh-1732)
                        s.url = cacheURL + uncached;

                        // Change '%20' to '+' if this is encoded form body content (gh-2658)
                    } else if (s.data && s.processData &&
                        (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) {
                        s.data = s.data.replace(r20, "+");
                    }

                    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
                    if (s.ifModified) {
                        if (jQuery.lastModified[cacheURL]) {
                            jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
                        }
                        if (jQuery.etag[cacheURL]) {
                            jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
                        }
                    }

                    // Set the correct header, if data is being sent
                    if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
                        jqXHR.setRequestHeader("Content-Type", s.contentType);
                    }

                    // Set the Accepts header for the server, depending on the dataType
                    jqXHR.setRequestHeader(
                        "Accept",
                        s.dataTypes[0] && s.accepts[s.dataTypes[0]] ?
                            s.accepts[s.dataTypes[0]] +
                            (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") :
                            s.accepts["*"]
                    );

                    // Check for headers option
                    for (i in s.headers) {
                        jqXHR.setRequestHeader(i, s.headers[i]);
                    }

                    // Allow custom headers/mimetypes and early abort
                    if (s.beforeSend &&
                        (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {

                        // Abort if not done already and return
                        return jqXHR.abort();
                    }

                    // Aborting is no longer a cancellation
                    strAbort = "abort";

                    // Install callbacks on deferreds
                    completeDeferred.add(s.complete);
                    jqXHR.done(s.success);
                    jqXHR.fail(s.error);

                    // Get transport
                    transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);

                    // If no transport, we auto-abort
                    if (!transport) {
                        done(-1, "No Transport");
                    } else {
                        jqXHR.readyState = 1;

                        // Send global event
                        if (fireGlobals) {
                            globalEventContext.trigger("ajaxSend", [jqXHR, s]);
                        }

                        // If request was aborted inside ajaxSend, stop there
                        if (completed) {
                            return jqXHR;
                        }

                        // Timeout
                        if (s.async && s.timeout > 0) {
                            timeoutTimer = window.setTimeout(function () {
                                jqXHR.abort("timeout");
                            }, s.timeout);
                        }

                        try {
                            completed = false;
                            transport.send(requestHeaders, done);
                        } catch (e) {

                            // Rethrow post-completion exceptions
                            if (completed) {
                                throw e;
                            }

                            // Propagate others as results
                            done(-1, e);
                        }
                    }

                    // Callback for when everything is done
                    function done(status, nativeStatusText, responses, headers) {
                        var isSuccess, success, error, response, modified,
                            statusText = nativeStatusText;

                        // Ignore repeat invocations
                        if (completed) {
                            return;
                        }

                        completed = true;

                        // Clear timeout if it exists
                        if (timeoutTimer) {
                            window.clearTimeout(timeoutTimer);
                        }

                        // Dereference transport for early garbage collection
                        // (no matter how long the jqXHR object will be used)
                        transport = undefined;

                        // Cache response headers
                        responseHeadersString = headers || "";

                        // Set readyState
                        jqXHR.readyState = status > 0 ? 4 : 0;

                        // Determine if successful
                        isSuccess = status >= 200 && status < 300 || status === 304;

                        // Get response data
                        if (responses) {
                            response = ajaxHandleResponses(s, jqXHR, responses);
                        }

                        // Convert no matter what (that way responseXXX fields are always set)
                        response = ajaxConvert(s, response, jqXHR, isSuccess);

                        // If successful, handle type chaining
                        if (isSuccess) {

                            // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
                            if (s.ifModified) {
                                modified = jqXHR.getResponseHeader("Last-Modified");
                                if (modified) {
                                    jQuery.lastModified[cacheURL] = modified;
                                }
                                modified = jqXHR.getResponseHeader("etag");
                                if (modified) {
                                    jQuery.etag[cacheURL] = modified;
                                }
                            }

                            // if no content
                            if (status === 204 || s.type === "HEAD") {
                                statusText = "nocontent";

                                // if not modified
                            } else if (status === 304) {
                                statusText = "notmodified";

                                // If we have data, let's convert it
                            } else {
                                statusText = response.state;
                                success = response.data;
                                error = response.error;
                                isSuccess = !error;
                            }
                        } else {

                            // Extract error from statusText and normalize for non-aborts
                            error = statusText;
                            if (status || !statusText) {
                                statusText = "error";
                                if (status < 0) {
                                    status = 0;
                                }
                            }
                        }

                        // Set data for the fake xhr object
                        jqXHR.status = status;
                        jqXHR.statusText = (nativeStatusText || statusText) + "";

                        // Success/Error
                        if (isSuccess) {
                            deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
                        } else {
                            deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
                        }

                        // Status-dependent callbacks
                        jqXHR.statusCode(statusCode);
                        statusCode = undefined;

                        if (fireGlobals) {
                            globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError",
                                [jqXHR, s, isSuccess ? success : error]);
                        }

                        // Complete
                        completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);

                        if (fireGlobals) {
                            globalEventContext.trigger("ajaxComplete", [jqXHR, s]);

                            // Handle the global AJAX counter
                            if (!(--jQuery.active)) {
                                jQuery.event.trigger("ajaxStop");
                            }
                        }
                    }

                    return jqXHR;
                },

                getJSON: function (url, data, callback) {
                    return jQuery.get(url, data, callback, "json");
                },

                getScript: function (url, callback) {
                    return jQuery.get(url, undefined, callback, "script");
                }
            });

            jQuery.each(["get", "post"], function (i, method) {
                jQuery[method] = function (url, data, callback, type) {

                    // Shift arguments if data argument was omitted
                    if (jQuery.isFunction(data)) {
                        type = type || callback;
                        callback = data;
                        data = undefined;
                    }

                    // The url can be an options object (which then must have .url)
                    return jQuery.ajax(jQuery.extend({
                        url: url,
                        type: method,
                        dataType: type,
                        data: data,
                        success: callback
                    }, jQuery.isPlainObject(url) && url));
                };
            });


            jQuery._evalUrl = function (url) {
                return jQuery.ajax({
                    url: url,

                    // Make this explicit, since user can override this through ajaxSetup (#11264)
                    type: "GET",
                    dataType: "script",
                    cache: true,
                    async: false,
                    global: false,
                    "throws": true
                });
            };


            jQuery.fn.extend({
                wrapAll: function (html) {
                    var wrap;

                    if (this[0]) {
                        if (jQuery.isFunction(html)) {
                            html = html.call(this[0]);
                        }

                        // The elements to wrap the target around
                        wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);

                        if (this[0].parentNode) {
                            wrap.insertBefore(this[0]);
                        }

                        wrap.map(function () {
                            var elem = this;

                            while (elem.firstElementChild) {
                                elem = elem.firstElementChild;
                            }

                            return elem;
                        }).append(this);
                    }

                    return this;
                },

                wrapInner: function (html) {
                    if (jQuery.isFunction(html)) {
                        return this.each(function (i) {
                            jQuery(this).wrapInner(html.call(this, i));
                        });
                    }

                    return this.each(function () {
                        var self = jQuery(this),
                            contents = self.contents();

                        if (contents.length) {
                            contents.wrapAll(html);

                        } else {
                            self.append(html);
                        }
                    });
                },

                wrap: function (html) {
                    var isFunction = jQuery.isFunction(html);

                    return this.each(function (i) {
                        jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
                    });
                },

                unwrap: function (selector) {
                    this.parent(selector).not("body").each(function () {
                        jQuery(this).replaceWith(this.childNodes);
                    });
                    return this;
                }
            });


            jQuery.expr.pseudos.hidden = function (elem) {
                return !jQuery.expr.pseudos.visible(elem);
            };
            jQuery.expr.pseudos.visible = function (elem) {
                return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
            };




            jQuery.ajaxSettings.xhr = function () {
                try {
                    return new window.XMLHttpRequest();
                } catch (e) { }
            };

            var xhrSuccessStatus = {

                // File protocol always yields status code 0, assume 200
                0: 200,

                // Support: IE <=9 only
                // #1450: sometimes IE returns 1223 when it should be 204
                1223: 204
            },
                xhrSupported = jQuery.ajaxSettings.xhr();

            support.cors = !!xhrSupported && ("withCredentials" in xhrSupported);
            support.ajax = xhrSupported = !!xhrSupported;

            jQuery.ajaxTransport(function (options) {
                var callback, errorCallback;

                // Cross domain only allowed if supported through XMLHttpRequest
                if (support.cors || xhrSupported && !options.crossDomain) {
                    return {
                        send: function (headers, complete) {
                            var i,
                                xhr = options.xhr();

                            xhr.open(
                                options.type,
                                options.url,
                                options.async,
                                options.username,
                                options.password
                            );

                            // Apply custom fields if provided
                            if (options.xhrFields) {
                                for (i in options.xhrFields) {
                                    xhr[i] = options.xhrFields[i];
                                }
                            }

                            // Override mime type if needed
                            if (options.mimeType && xhr.overrideMimeType) {
                                xhr.overrideMimeType(options.mimeType);
                            }

                            // X-Requested-With header
                            // For cross-domain requests, seeing as conditions for a preflight are
                            // akin to a jigsaw puzzle, we simply never set it to be sure.
                            // (it can always be set on a per-request basis or even using ajaxSetup)
                            // For same-domain requests, won't change header if already provided.
                            if (!options.crossDomain && !headers["X-Requested-With"]) {
                                headers["X-Requested-With"] = "XMLHttpRequest";
                            }

                            // Set headers
                            for (i in headers) {
                                xhr.setRequestHeader(i, headers[i]);
                            }

                            // Callback
                            callback = function (type) {
                                return function () {
                                    if (callback) {
                                        callback = errorCallback = xhr.onload =
                                            xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;

                                        if (type === "abort") {
                                            xhr.abort();
                                        } else if (type === "error") {

                                            // Support: IE <=9 only
                                            // On a manual native abort, IE9 throws
                                            // errors on any property access that is not readyState
                                            if (typeof xhr.status !== "number") {
                                                complete(0, "error");
                                            } else {
                                                complete(

                                                    // File: protocol always yields status 0; see #8605, #14207
                                                    xhr.status,
                                                    xhr.statusText
                                                );
                                            }
                                        } else {
                                            complete(
                                                xhrSuccessStatus[xhr.status] || xhr.status,
                                                xhr.statusText,

                                                // Support: IE <=9 only
                                                // IE9 has no XHR2 but throws on binary (trac-11426)
                                                // For XHR2 non-text, let the caller handle it (gh-2498)
                                                (xhr.responseType || "text") !== "text" ||
                                                    typeof xhr.responseText !== "string" ?
                                                    { binary: xhr.response } :
                                                    { text: xhr.responseText },
                                                xhr.getAllResponseHeaders()
                                            );
                                        }
                                    }
                                };
                            };

                            // Listen to events
                            xhr.onload = callback();
                            errorCallback = xhr.onerror = callback("error");

                            // Support: IE 9 only
                            // Use onreadystatechange to replace onabort
                            // to handle uncaught aborts
                            if (xhr.onabort !== undefined) {
                                xhr.onabort = errorCallback;
                            } else {
                                xhr.onreadystatechange = function () {

                                    // Check readyState before timeout as it changes
                                    if (xhr.readyState === 4) {

                                        // Allow onerror to be called first,
                                        // but that will not handle a native abort
                                        // Also, save errorCallback to a variable
                                        // as xhr.onerror cannot be accessed
                                        window.setTimeout(function () {
                                            if (callback) {
                                                errorCallback();
                                            }
                                        });
                                    }
                                };
                            }

                            // Create the abort callback
                            callback = callback("abort");

                            try {

                                // Do send the request (this may raise an exception)
                                xhr.send(options.hasContent && options.data || null);
                            } catch (e) {

                                // #14683: Only rethrow if this hasn't been notified as an error yet
                                if (callback) {
                                    throw e;
                                }
                            }
                        },

                        abort: function () {
                            if (callback) {
                                callback();
                            }
                        }
                    };
                }
            });




            // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
            jQuery.ajaxPrefilter(function (s) {
                if (s.crossDomain) {
                    s.contents.script = false;
                }
            });

            // Install script dataType
            jQuery.ajaxSetup({
                accepts: {
                    script: "text/javascript, application/javascript, " +
                        "application/ecmascript, application/x-ecmascript"
                },
                contents: {
                    script: /\b(?:java|ecma)script\b/
                },
                converters: {
                    "text script": function (text) {
                        jQuery.globalEval(text);
                        return text;
                    }
                }
            });

            // Handle cache's special case and crossDomain
            jQuery.ajaxPrefilter("script", function (s) {
                if (s.cache === undefined) {
                    s.cache = false;
                }
                if (s.crossDomain) {
                    s.type = "GET";
                }
            });

            // Bind script tag hack transport
            jQuery.ajaxTransport("script", function (s) {

                // This transport only deals with cross domain requests
                if (s.crossDomain) {
                    var script, callback;
                    return {
                        send: function (_, complete) {
                            script = jQuery("<script>").prop({
                                charset: s.scriptCharset,
                                src: s.url
                            }).on(
                                "load error",
                                callback = function (evt) {
                                    script.remove();
                                    callback = null;
                                    if (evt) {
                                        complete(evt.type === "error" ? 404 : 200, evt.type);
                                    }
                                }
                            );

                            // Use native DOM manipulation to avoid our domManip AJAX trickery
                            document.head.appendChild(script[0]);
                        },
                        abort: function () {
                            if (callback) {
                                callback();
                            }
                        }
                    };
                }
            });




            var oldCallbacks = [],
                rjsonp = /(=)\?(?=&|$)|\?\?/;

            // Default jsonp settings
            jQuery.ajaxSetup({
                jsonp: "callback",
                jsonpCallback: function () {
                    var callback = oldCallbacks.pop() || (jQuery.expando + "_" + (nonce++));
                    this[callback] = true;
                    return callback;
                }
            });

            // Detect, normalize options and install callbacks for jsonp requests
            jQuery.ajaxPrefilter("json jsonp", function (s, originalSettings, jqXHR) {

                var callbackName, overwritten, responseContainer,
                    jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ?
                        "url" :
                        typeof s.data === "string" &&
                        (s.contentType || "")
                            .indexOf("application/x-www-form-urlencoded") === 0 &&
                        rjsonp.test(s.data) && "data"
                    );

                // Handle iff the expected data type is "jsonp" or we have a parameter to set
                if (jsonProp || s.dataTypes[0] === "jsonp") {

                    // Get callback name, remembering preexisting value associated with it
                    callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ?
                        s.jsonpCallback() :
                        s.jsonpCallback;

                    // Insert callback into url or form data
                    if (jsonProp) {
                        s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
                    } else if (s.jsonp !== false) {
                        s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
                    }

                    // Use data converter to retrieve json after script execution
                    s.converters["script json"] = function () {
                        if (!responseContainer) {
                            jQuery.error(callbackName + " was not called");
                        }
                        return responseContainer[0];
                    };

                    // Force json dataType
                    s.dataTypes[0] = "json";

                    // Install callback
                    overwritten = window[callbackName];
                    window[callbackName] = function () {
                        responseContainer = arguments;
                    };

                    // Clean-up function (fires after converters)
                    jqXHR.always(function () {

                        // If previous value didn't exist - remove it
                        if (overwritten === undefined) {
                            jQuery(window).removeProp(callbackName);

                            // Otherwise restore preexisting value
                        } else {
                            window[callbackName] = overwritten;
                        }

                        // Save back as free
                        if (s[callbackName]) {

                            // Make sure that re-using the options doesn't screw things around
                            s.jsonpCallback = originalSettings.jsonpCallback;

                            // Save the callback name for future use
                            oldCallbacks.push(callbackName);
                        }

                        // Call if it was a function and we have a response
                        if (responseContainer && jQuery.isFunction(overwritten)) {
                            overwritten(responseContainer[0]);
                        }

                        responseContainer = overwritten = undefined;
                    });

                    // Delegate to script
                    return "script";
                }
            });




            // Support: Safari 8 only
            // In Safari 8 documents created via document.implementation.createHTMLDocument
            // collapse sibling forms: the second one becomes a child of the first one.
            // Because of that, this security measure has to be disabled in Safari 8.
            // https://bugs.webkit.org/show_bug.cgi?id=137337
            support.createHTMLDocument = (function () {
                var body = document.implementation.createHTMLDocument("").body;
                body.innerHTML = "<form></form><form></form>";
                return body.childNodes.length === 2;
            })();


            // Argument "data" should be string of html
            // context (optional): If specified, the fragment will be created in this context,
            // defaults to document
            // keepScripts (optional): If true, will include scripts passed in the html string
            jQuery.parseHTML = function (data, context, keepScripts) {
                if (typeof data !== "string") {
                    return [];
                }
                if (typeof context === "boolean") {
                    keepScripts = context;
                    context = false;
                }

                var base, parsed, scripts;

                if (!context) {

                    // Stop scripts or inline event handlers from being executed immediately
                    // by using document.implementation
                    if (support.createHTMLDocument) {
                        context = document.implementation.createHTMLDocument("");

                        // Set the base href for the created document
                        // so any parsed elements with URLs
                        // are based on the document's URL (gh-2965)
                        base = context.createElement("base");
                        base.href = document.location.href;
                        context.head.appendChild(base);
                    } else {
                        context = document;
                    }
                }

                parsed = rsingleTag.exec(data);
                scripts = !keepScripts && [];

                // Single tag
                if (parsed) {
                    return [context.createElement(parsed[1])];
                }

                parsed = buildFragment([data], context, scripts);

                if (scripts && scripts.length) {
                    jQuery(scripts).remove();
                }

                return jQuery.merge([], parsed.childNodes);
            };


            /**
             * Load a url into a page
             */
            jQuery.fn.load = function (url, params, callback) {
                var selector, type, response,
                    self = this,
                    off = url.indexOf(" ");

                if (off > -1) {
                    selector = stripAndCollapse(url.slice(off));
                    url = url.slice(0, off);
                }

                // If it's a function
                if (jQuery.isFunction(params)) {

                    // We assume that it's the callback
                    callback = params;
                    params = undefined;

                    // Otherwise, build a param string
                } else if (params && typeof params === "object") {
                    type = "POST";
                }

                // If we have elements to modify, make the request
                if (self.length > 0) {
                    jQuery.ajax({
                        url: url,

                        // If "type" variable is undefined, then "GET" method will be used.
                        // Make value of this field explicit since
                        // user can override it through ajaxSetup method
                        type: type || "GET",
                        dataType: "html",
                        data: params
                    }).done(function (responseText) {

                        // Save response for use in complete callback
                        response = arguments;

                        self.html(selector ?

                            // If a selector was specified, locate the right elements in a dummy div
                            // Exclude scripts to avoid IE 'Permission Denied' errors
                            jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) :

                            // Otherwise use the full result
                            responseText);

                        // If the request succeeds, this function gets "data", "status", "jqXHR"
                        // but they are ignored because response was set above.
                        // If it fails, this function gets "jqXHR", "status", "error"
                    }).always(callback && function (jqXHR, status) {
                        self.each(function () {
                            callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);
                        });
                    });
                }

                return this;
            };




            // Attach a bunch of functions for handling common AJAX events
            jQuery.each([
                "ajaxStart",
                "ajaxStop",
                "ajaxComplete",
                "ajaxError",
                "ajaxSuccess",
                "ajaxSend"
            ], function (i, type) {
                jQuery.fn[type] = function (fn) {
                    return this.on(type, fn);
                };
            });




            jQuery.expr.pseudos.animated = function (elem) {
                return jQuery.grep(jQuery.timers, function (fn) {
                    return elem === fn.elem;
                }).length;
            };




            jQuery.offset = {
                setOffset: function (elem, options, i) {
                    var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
                        position = jQuery.css(elem, "position"),
                        curElem = jQuery(elem),
                        props = {};

                    // Set position first, in-case top/left are set even on static elem
                    if (position === "static") {
                        elem.style.position = "relative";
                    }

                    curOffset = curElem.offset();
                    curCSSTop = jQuery.css(elem, "top");
                    curCSSLeft = jQuery.css(elem, "left");
                    calculatePosition = (position === "absolute" || position === "fixed") &&
                        (curCSSTop + curCSSLeft).indexOf("auto") > -1;

                    // Need to be able to calculate position if either
                    // top or left is auto and position is either absolute or fixed
                    if (calculatePosition) {
                        curPosition = curElem.position();
                        curTop = curPosition.top;
                        curLeft = curPosition.left;

                    } else {
                        curTop = parseFloat(curCSSTop) || 0;
                        curLeft = parseFloat(curCSSLeft) || 0;
                    }

                    if (jQuery.isFunction(options)) {

                        // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
                        options = options.call(elem, i, jQuery.extend({}, curOffset));
                    }

                    if (options.top != null) {
                        props.top = (options.top - curOffset.top) + curTop;
                    }
                    if (options.left != null) {
                        props.left = (options.left - curOffset.left) + curLeft;
                    }

                    if ("using" in options) {
                        options.using.call(elem, props);

                    } else {
                        curElem.css(props);
                    }
                }
            };

            jQuery.fn.extend({
                offset: function (options) {

                    // Preserve chaining for setter
                    if (arguments.length) {
                        return options === undefined ?
                            this :
                            this.each(function (i) {
                                jQuery.offset.setOffset(this, options, i);
                            });
                    }

                    var doc, docElem, rect, win,
                        elem = this[0];

                    if (!elem) {
                        return;
                    }

                    // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
                    // Support: IE <=11 only
                    // Running getBoundingClientRect on a
                    // disconnected node in IE throws an error
                    if (!elem.getClientRects().length) {
                        return { top: 0, left: 0 };
                    }

                    rect = elem.getBoundingClientRect();

                    doc = elem.ownerDocument;
                    docElem = doc.documentElement;
                    win = doc.defaultView;

                    return {
                        top: rect.top + win.pageYOffset - docElem.clientTop,
                        left: rect.left + win.pageXOffset - docElem.clientLeft
                    };
                },

                position: function () {
                    if (!this[0]) {
                        return;
                    }

                    var offsetParent, offset,
                        elem = this[0],
                        parentOffset = { top: 0, left: 0 };

                    // Fixed elements are offset from window (parentOffset = {top:0, left: 0},
                    // because it is its only offset parent
                    if (jQuery.css(elem, "position") === "fixed") {

                        // Assume getBoundingClientRect is there when computed position is fixed
                        offset = elem.getBoundingClientRect();

                    } else {

                        // Get *real* offsetParent
                        offsetParent = this.offsetParent();

                        // Get correct offsets
                        offset = this.offset();
                        if (!nodeName(offsetParent[0], "html")) {
                            parentOffset = offsetParent.offset();
                        }

                        // Add offsetParent borders
                        parentOffset = {
                            top: parentOffset.top + jQuery.css(offsetParent[0], "borderTopWidth", true),
                            left: parentOffset.left + jQuery.css(offsetParent[0], "borderLeftWidth", true)
                        };
                    }

                    // Subtract parent offsets and element margins
                    return {
                        top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
                        left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)
                    };
                },

                // This method will return documentElement in the following cases:
                // 1) For the element inside the iframe without offsetParent, this method will return
                //    documentElement of the parent window
                // 2) For the hidden or detached element
                // 3) For body or html element, i.e. in case of the html node - it will return itself
                //
                // but those exceptions were never presented as a real life use-cases
                // and might be considered as more preferable results.
                //
                // This logic, however, is not guaranteed and can change at any point in the future
                offsetParent: function () {
                    return this.map(function () {
                        var offsetParent = this.offsetParent;

                        while (offsetParent && jQuery.css(offsetParent, "position") === "static") {
                            offsetParent = offsetParent.offsetParent;
                        }

                        return offsetParent || documentElement;
                    });
                }
            });

            // Create scrollLeft and scrollTop methods
            jQuery.each({ scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function (method, prop) {
                var top = "pageYOffset" === prop;

                jQuery.fn[method] = function (val) {
                    return access(this, function (elem, method, val) {

                        // Coalesce documents and windows
                        var win;
                        if (jQuery.isWindow(elem)) {
                            win = elem;
                        } else if (elem.nodeType === 9) {
                            win = elem.defaultView;
                        }

                        if (val === undefined) {
                            return win ? win[prop] : elem[method];
                        }

                        if (win) {
                            win.scrollTo(
                                !top ? val : win.pageXOffset,
                                top ? val : win.pageYOffset
                            );

                        } else {
                            elem[method] = val;
                        }
                    }, method, val, arguments.length);
                };
            });

            // Support: Safari <=7 - 9.1, Chrome <=37 - 49
            // Add the top/left cssHooks using jQuery.fn.position
            // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
            // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
            // getComputedStyle returns percent when specified for top/left/bottom/right;
            // rather than make the css module depend on the offset module, just check for it here
            jQuery.each(["top", "left"], function (i, prop) {
                jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition,
                    function (elem, computed) {
                        if (computed) {
                            computed = curCSS(elem, prop);

                            // If curCSS returns percentage, fallback to offset
                            return rnumnonpx.test(computed) ?
                                jQuery(elem).position()[prop] + "px" :
                                computed;
                        }
                    }
                );
            });


            // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
            jQuery.each({ Height: "height", Width: "width" }, function (name, type) {
                jQuery.each({ padding: "inner" + name, content: type, "": "outer" + name },
                    function (defaultExtra, funcName) {

                        // Margin is only for outerHeight, outerWidth
                        jQuery.fn[funcName] = function (margin, value) {
                            var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"),
                                extra = defaultExtra || (margin === true || value === true ? "margin" : "border");

                            return access(this, function (elem, type, value) {
                                var doc;

                                if (jQuery.isWindow(elem)) {

                                    // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
                                    return funcName.indexOf("outer") === 0 ?
                                        elem["inner" + name] :
                                        elem.document.documentElement["client" + name];
                                }

                                // Get document width or height
                                if (elem.nodeType === 9) {
                                    doc = elem.documentElement;

                                    // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
                                    // whichever is greatest
                                    return Math.max(
                                        elem.body["scroll" + name], doc["scroll" + name],
                                        elem.body["offset" + name], doc["offset" + name],
                                        doc["client" + name]
                                    );
                                }

                                return value === undefined ?

                                    // Get width or height on the element, requesting but not forcing parseFloat
                                    jQuery.css(elem, type, extra) :

                                    // Set width or height on the element
                                    jQuery.style(elem, type, value, extra);
                            }, type, chainable ? margin : undefined, chainable);
                        };
                    });
            });


            jQuery.fn.extend({

                bind: function (types, data, fn) {
                    return this.on(types, null, data, fn);
                },
                unbind: function (types, fn) {
                    return this.off(types, null, fn);
                },

                delegate: function (selector, types, data, fn) {
                    return this.on(types, selector, data, fn);
                },
                undelegate: function (selector, types, fn) {

                    // ( namespace ) or ( selector, types [, fn] )
                    return arguments.length === 1 ?
                        this.off(selector, "**") :
                        this.off(types, selector || "**", fn);
                }
            });

            jQuery.holdReady = function (hold) {
                if (hold) {
                    jQuery.readyWait++;
                } else {
                    jQuery.ready(true);
                }
            };
            jQuery.isArray = Array.isArray;
            jQuery.parseJSON = JSON.parse;
            jQuery.nodeName = nodeName;




            // Register as a named AMD module, since jQuery can be concatenated with other
            // files that may use define, but not via a proper concatenation script that
            // understands anonymous AMD modules. A named AMD is safest and most robust
            // way to register. Lowercase jquery is used because AMD module names are
            // derived from file names, and jQuery is normally delivered in a lowercase
            // file name. Do this after creating the global so that if an AMD module wants
            // to call noConflict to hide this version of jQuery, it will work.

            // Note that for maximum portability, libraries that are not jQuery should
            // declare themselves as anonymous modules, and avoid setting a global if an
            // AMD loader is present. jQuery is a special case. For more information, see
            // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon

            if (true) {
                !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {
                    return jQuery;
                }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
                    __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
            }




            var

                // Map over jQuery in case of overwrite
                _jQuery = window.jQuery,

                // Map over the $ in case of overwrite
                _$ = window.$;

            jQuery.noConflict = function (deep) {
                if (window.$ === jQuery) {
                    window.$ = _$;
                }

                if (deep && window.jQuery === jQuery) {
                    window.jQuery = _jQuery;
                }

                return jQuery;
            };

            // Expose jQuery and $ identifiers, even in AMD
            // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
            // and CommonJS for browser emulators (#13566)
            if (!noGlobal) {
                window.jQuery = window.$ = jQuery;
            }




            return jQuery;
        });


        /***/
    }),
/* 1 */
/***/ (function (module, exports, __webpack_require__) {

        var store = __webpack_require__(42)('wks')
            , uid = __webpack_require__(32)
            , Symbol = __webpack_require__(3).Symbol
            , USE_SYMBOL = typeof Symbol == 'function';

        var $exports = module.exports = function (name) {
            return store[name] || (store[name] =
                USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
        };

        $exports.store = store;

        /***/
    }),
/* 2 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var cls = __webpack_require__(23);
        var defaultSettings = __webpack_require__(108);
        var dom = __webpack_require__(8);
        var EventManager = __webpack_require__(105);
        var guid = __webpack_require__(106);

        var instances = {};

        function Instance(element) {
            var i = this;

            i.settings = _.clone(defaultSettings);
            i.containerWidth = null;
            i.containerHeight = null;
            i.contentWidth = null;
            i.contentHeight = null;

            i.isRtl = dom.css(element, 'direction') === "rtl";
            i.isNegativeScroll = (function () {
                var originalScrollLeft = element.scrollLeft;
                var result = null;
                element.scrollLeft = -1;
                result = element.scrollLeft < 0;
                element.scrollLeft = originalScrollLeft;
                return result;
            })();
            i.negativeScrollAdjustment = i.isNegativeScroll ? element.scrollWidth - element.clientWidth : 0;
            i.event = new EventManager();
            i.ownerDocument = element.ownerDocument || document;

            function focus() {
                cls.add(element, 'ps--focus');
            }

            function blur() {
                cls.remove(element, 'ps--focus');
            }

            i.scrollbarXRail = dom.appendTo(dom.e('div', 'ps__scrollbar-x-rail'), element);
            i.scrollbarX = dom.appendTo(dom.e('div', 'ps__scrollbar-x'), i.scrollbarXRail);
            i.scrollbarX.setAttribute('tabindex', 0);
            i.event.bind(i.scrollbarX, 'focus', focus);
            i.event.bind(i.scrollbarX, 'blur', blur);
            i.scrollbarXActive = null;
            i.scrollbarXWidth = null;
            i.scrollbarXLeft = null;
            i.scrollbarXBottom = _.toInt(dom.css(i.scrollbarXRail, 'bottom'));
            i.isScrollbarXUsingBottom = i.scrollbarXBottom === i.scrollbarXBottom; // !isNaN
            i.scrollbarXTop = i.isScrollbarXUsingBottom ? null : _.toInt(dom.css(i.scrollbarXRail, 'top'));
            i.railBorderXWidth = _.toInt(dom.css(i.scrollbarXRail, 'borderLeftWidth')) + _.toInt(dom.css(i.scrollbarXRail, 'borderRightWidth'));
            // Set rail to display:block to calculate margins
            dom.css(i.scrollbarXRail, 'display', 'block');
            i.railXMarginWidth = _.toInt(dom.css(i.scrollbarXRail, 'marginLeft')) + _.toInt(dom.css(i.scrollbarXRail, 'marginRight'));
            dom.css(i.scrollbarXRail, 'display', '');
            i.railXWidth = null;
            i.railXRatio = null;

            i.scrollbarYRail = dom.appendTo(dom.e('div', 'ps__scrollbar-y-rail'), element);
            i.scrollbarY = dom.appendTo(dom.e('div', 'ps__scrollbar-y'), i.scrollbarYRail);
            i.scrollbarY.setAttribute('tabindex', 0);
            i.event.bind(i.scrollbarY, 'focus', focus);
            i.event.bind(i.scrollbarY, 'blur', blur);
            i.scrollbarYActive = null;
            i.scrollbarYHeight = null;
            i.scrollbarYTop = null;
            i.scrollbarYRight = _.toInt(dom.css(i.scrollbarYRail, 'right'));
            i.isScrollbarYUsingRight = i.scrollbarYRight === i.scrollbarYRight; // !isNaN
            i.scrollbarYLeft = i.isScrollbarYUsingRight ? null : _.toInt(dom.css(i.scrollbarYRail, 'left'));
            i.scrollbarYOuterWidth = i.isRtl ? _.outerWidth(i.scrollbarY) : null;
            i.railBorderYWidth = _.toInt(dom.css(i.scrollbarYRail, 'borderTopWidth')) + _.toInt(dom.css(i.scrollbarYRail, 'borderBottomWidth'));
            dom.css(i.scrollbarYRail, 'display', 'block');
            i.railYMarginHeight = _.toInt(dom.css(i.scrollbarYRail, 'marginTop')) + _.toInt(dom.css(i.scrollbarYRail, 'marginBottom'));
            dom.css(i.scrollbarYRail, 'display', '');
            i.railYHeight = null;
            i.railYRatio = null;
        }

        function getId(element) {
            return element.getAttribute('data-ps-id');
        }

        function setId(element, id) {
            element.setAttribute('data-ps-id', id);
        }

        function removeId(element) {
            element.removeAttribute('data-ps-id');
        }

        exports.add = function (element) {
            var newId = guid();
            setId(element, newId);
            instances[newId] = new Instance(element);
            return instances[newId];
        };

        exports.remove = function (element) {
            delete instances[getId(element)];
            removeId(element);
        };

        exports.get = function (element) {
            return instances[getId(element)];
        };


        /***/
    }),
/* 3 */
/***/ (function (module, exports) {

        // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
        var global = module.exports = typeof window != 'undefined' && window.Math == Math
            ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
        if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef

        /***/
    }),
/* 4 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.addCustomScroll = addCustomScroll;
        exports.updateCustomScroll = updateCustomScroll;
        exports.destroyCustomScroll = destroyCustomScroll;
        exports.scrollTo = scrollTo;
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _perfectScrollbar = __webpack_require__(104);

        var _perfectScrollbar2 = _interopRequireDefault(_perfectScrollbar);

        var _inspirationModal = __webpack_require__(11);

        var _mapServiceMarkers = __webpack_require__(33);

        var _jsPagination = __webpack_require__(103);

        var _jsPagination2 = _interopRequireDefault(_jsPagination);

        var _buttonBlack = __webpack_require__(17);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var isMobileDevice = /iPhone|iPad|iPod|Android|blackberry|nokia|opera mini|windows mobile|windows phone|iemobile/i.test(navigator.userAgent);

        /**
         * addCustomScroll
         */
        function addCustomScroll(className, isArray) {
            var el = document.querySelector(className);
            if (!_perfectScrollbar2.default || !(0, _jquery2.default)(className) || !(0, _jquery2.default)(className).length) {
                return;
            }
            if (isArray) {
                (0, _jquery2.default)(className).each(function (idx, item) {
                    _perfectScrollbar2.default.destroy((0, _jquery2.default)(item).get(0));
                    _perfectScrollbar2.default.initialize((0, _jquery2.default)(item).get(0));
                });
                (0, _jquery2.default)(window).on('load', function () {
                    (0, _jquery2.default)(className).each(function (idx, item) {
                        _perfectScrollbar2.default.update((0, _jquery2.default)(item).get(0));
                    });
                });
                return;
            }

            _perfectScrollbar2.default.destroy(el);
            _perfectScrollbar2.default.initialize(el);
            (0, _jquery2.default)(window).on('load', function () {
                _perfectScrollbar2.default.update(el);
            });
        }

        /**
         * updateCustomScroll
         */
        function updateCustomScroll(className, isArray) {
            var el = document.querySelector(className);
            if (!_perfectScrollbar2.default || !(0, _jquery2.default)(className) || !(0, _jquery2.default)(className).length) {
                return;
            }
            if (isArray) {
                (0, _jquery2.default)(className).each(function (idx, item) {
                    _perfectScrollbar2.default.update((0, _jquery2.default)(item).get(0));
                });
                return;
            }

            _perfectScrollbar2.default.update(el);
        }

        /**
         * destroy CustomS croll
         */
        function destroyCustomScroll(className) {
            var el = document.querySelector(className);
            if (!_perfectScrollbar2.default || !(0, _jquery2.default)(className) || !(0, _jquery2.default)(className).length) {
                return;
            }
            _perfectScrollbar2.default.destroy(el);
        }

        /**
         * How to use: scrollTo($('#google-map'), $('.header'));
         * @param container
         */
        function scrollTo(container, elExclude) {
            var delay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 750;

            (0, _jquery2.default)('html, body').animate({
                scrollTop: parseInt(container.offset().top - elExclude.height(), 10)
            }, delay);
        }

        var $header = (0, _jquery2.default)('.header');

        /**
         * isMobile
         * @returns {boolean}
         */
        function isMobile() {
            var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
            return browserWidth <= 767;
        }

        /**
         * @param mapElement {element}
         * @param toggleBox {element}
         * @param uList {element}
         * @param correctHeight {int}
         */
        function resetHeightMap(_ref) {
            var mapElement = _ref.mapElement,
                toggleBox = _ref.toggleBox,
                uList = _ref.uList,
                correctHeight = _ref.correctHeight;

            var scrollbarVisible = function scrollbarVisible(element, fullyInView) {
                var pageTop = (0, _jquery2.default)(window).scrollTop();
                var pageBottom = pageTop + (0, _jquery2.default)(window).height();
                var elementTop = (0, _jquery2.default)(element).offset().top;
                var elementBottom = elementTop + (0, _jquery2.default)(element).height();

                if (fullyInView === true) {
                    return pageTop < elementTop && pageBottom > elementBottom;
                } else {
                    return elementTop <= pageBottom && elementBottom >= pageTop;
                }
            };
            var minHeight = '800px';

            if (scrollbarVisible(toggleBox)) {
                //mapElement.css({ 'height': correctHeight, 'min-height': minHeight });
                mapElement.css({ 'height':'55px' });    //because this was adding a layer over the mappointers.   
                toggleBox.css({ 'height': correctHeight, 'min-height': minHeight });
                uList.css({ 'max-height': correctHeight, 'min-height': minHeight });
            }
        }

        /**
         * Toggle form popup
         */
    function toggleListener(map) {
        var $contactMapWrapper = (0, _jquery2.default)('.contact-map');
        var $contactMapStoreList = (0, _jquery2.default)('.store-carts-list');
        var $closeBtn = (0, _jquery2.default)('.js_toggle-close');
        // const $listBtn = $('.contact-button-wrapper .button-black ', $contactMapStoreList);
        var $listItems = (0, _jquery2.default)('.store-carts-list__item', $contactMapStoreList);
        var $toggleBox = (0, _jquery2.default)('.toggle-box');
        var $toggleBoxOpenClass = 'toggle-box--opened';
        var DEFAULT_MAPZOOM = 10;

        // $('.Form__MainBody .Form__Element.FormHidden').hide(); //copy val to hidden input
        var blackButtonListener = function blackButtonListener(e, thisCard) {
            // const thisCard = $(e.target).closest('li');
            var formContactorName = (0, _jquery2.default)('.contact-name', $toggleBox);
            var formContactorEmail = (0, _jquery2.default)('.contact-mail', $toggleBox);
            var formContactorLoc = (0, _jquery2.default)('.contact-loc', $toggleBox);
            formContactorEmail.hide();
            var resetHeightConf = function resetHeightConf() {
                return {
                    'mapElement': $contactMapWrapper.children().first(),
                    'toggleBox': $toggleBox.children(),
                    'uList': (0, _jquery2.default)('ul.store-carts-list'),
                    'correctHeight': $toggleBox.children().get(0).scrollHeight
                };
            };
            e.preventDefault();
            resetHeightMap(resetHeightConf());

            if (!isMobile()) {
                // $('.Form__MainBody .Form__Element.FormHidden').val($('.title', thisCard).text()); //copy val to hidden input
                formContactorName.text((0, _jquery2.default)('.title', thisCard).text());
                formContactorEmail.text((0, _jquery2.default)('.contact-email', thisCard).text());
                formContactorLoc.text((0, _jquery2.default)('.contact-loc-id', thisCard).text());

                $toggleBox.addClass($toggleBoxOpenClass);
                updateCustomScroll('.toggle-box .js_custom-scroll');
                (0, _jquery2.default)('li.active', '.store-carts-list').removeClass('active');
                (0, _jquery2.default)(e.target).closest('li').addClass('active');
            }
            return;
        };
        $contactMapStoreList.on('click', 'li', newFunction);
        $closeBtn.on('click', function () {
            (0, _inspirationModal.toggler)($toggleBox, $toggleBoxOpenClass);
        });

        function newFunction(e) {

            var $thisCard = (0, _jquery2.default)(e.target).closest('li');
            var formActiveCls = 'form--opened';
            var formContactorName = (0, _jquery2.default)('.contact-name', $toggleBox);
            var formContactorLoc = (0, _jquery2.default)('.contact-loc', $toggleBox);

            // const browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
            var mobileShowLocation = function mobileShowLocation(map) {
                var locationData = $thisCard.attr('data-installer-geoposition');
                var mapCenterCard = {
                    lat: parseFloat(locationData.split(',')[0], 10),
                    lng: parseFloat(locationData.split(',')[1], 10)
                };
                var zoom = (0, _jquery2.default)(e.target).closest('ul').attr('data-icontact-zoom') || DEFAULT_MAPZOOM;
                (0, _jquery2.default)('.map-button', '.results-box').trigger('click');

                map.setCenter(mapCenterCard);
                map.setZoom(parseInt(zoom, 10));
            };

            if ($thisCard.hasClass('store-carts-list__item--no-results')) {
                return false;
            }
            if (e.target.nodeName === 'BUTTON') {
                blackButtonListener(e, $thisCard);
                return false;
            }

            if (e.target.nodeName === "A") {
                var url = e.target.href;
                window.open(url, "_blank");
                return false;
            }

            if (!isMobile()) {
                return false;
            }



            // mobile mode
            if ((0, _jquery2.default)(e.target).hasClass('open-form__corner')) {
                mobileShowLocation(map);
                return false;
            }




            if (episitename === "Domal") {
                var links = e.currentTarget.querySelector("a.button-black");
                window.open(links.href, "_blank");
                return false;
            }

            formContactorName.text((0, _jquery2.default)('.title', $thisCard).text());
            formContactorLoc.text((0, _jquery2.default)('.contact-loc-id', $thisCard).text());

            if (!$thisCard.hasClass(formActiveCls)) {
                $listItems.removeClass(formActiveCls);
                $listItems.removeClass('form--closed'); // need to prevent gap when cart order is changing
                $thisCard.addClass('form--closed');
            }
            $thisCard.toggleClass(formActiveCls + ' active');

            if ($toggleBox.hasClass('toggle-box--opened')) {
                $toggleBox.removeClass('toggle-box--opened');
            }

            // avoid splash
            setTimeout(function () {
                if ($thisCard.hasClass(formActiveCls)) {
                    $toggleBox.addClass('toggle-box--opened');
                }
            }, 100);
            return false;

        };

        window.SAPATECH.eh = newFunction;
    }

        /**
         * add Styles to Pager
         */
        function addStylesPager() {
            var pagerList = (0, _jquery2.default)('.pager');
            var listItems = (0, _jquery2.default)('li', pagerList);

            pagerList.addClass('js_pager');
            listItems.addClass('pager__item');

            listItems.each(function (idx, item) {
                if ((0, _jquery2.default)(item).attr('title') === 'Pre page' || (0, _jquery2.default)(item).attr('title') === 'Next page' || typeof (0, _jquery2.default)(item).attr('title') === 'undefined') {
                    (0, _jquery2.default)(item).addClass('pager__item--without-separator');

                    if ((0, _jquery2.default)(item).attr('title') === 'Next page') {
                        (0, _jquery2.default)(item).prev().addClass('pager__item--without-separator');
                        (0, _jquery2.default)(item).text('').append('<span class="pager__link pager__link--next">');
                    }
                    if ((0, _jquery2.default)(item).attr('title') === 'Pre page') {
                        (0, _jquery2.default)(item).text('').append('<span class="pager__link pager__link--prev">');
                    }
                } else {
                    // listItems.addClass('pager__item--without-separator');
                }
            });
        }

        /**
         * toggleCard visibilyty
         */
        function toggleCardPagination(pageNumber, isDesktop) {
            var cardList = (0, _jquery2.default)('ul.store-carts-list');
            var cardItems = (0, _jquery2.default)('li.store-carts-list__item[data-include="on"]', cardList);
            var closeForm = function closeForm() {
                var $form = (0, _jquery2.default)('.wrapper-contact-form--map .toggle-box');

                if ($form.hasClass('toggle-box--opened')) {
                    $form.removeClass('toggle-box--opened');
                }
                if (cardItems.hasClass('form--opened active')) {
                    cardItems.removeClass('form--opened active');
                }
            };

            closeForm();
            // Use For Instead of Each
            var cardItemsLen = cardItems.length;
            var pageShow = 0;
            for (var ii = 0; ii <= cardItemsLen; ii++) {
                if (ii % 10 === 0) {
                    pageShow++;
                }
                (0, _jquery2.default)(cardItems[ii]).attr('data-pagination', pageShow);
            }
            for (var _ii = 0; _ii < cardItemsLen; _ii++) {
                var itemNumber = parseInt((0, _jquery2.default)(cardItems[_ii]).attr('data-pagination'), 10);
                var isOn = (0, _jquery2.default)(cardItems[_ii]).attr('data-include');
                if (itemNumber !== pageNumber || isOn === 'off') {
                    (0, _jquery2.default)(cardItems[_ii]).hide();
                } else {
                    (0, _jquery2.default)(cardItems[_ii]).show();
                }
                if (isDesktop) {
                    (0, _jquery2.default)(cardItems[_ii]).show();
                }
                if (isOn !== 'on') {
                    (0, _jquery2.default)(cardItems[_ii]).hide();
                }
            }
            (0, _jquery2.default)('li.store-carts-list__item[data-include="off"]', cardList).hide();
        }

        /**
         * Toggle Required Text
         */
        function contactMapInit() {
            var $contactMapWrapper = (0, _jquery2.default)('.contact-map');
            var $contactMap = (0, _jquery2.default)('#google-map', $contactMapWrapper);
            var $listWrapper = (0, _jquery2.default)('.store-carts-list-wrapper');
            var $contactMapStoreList = (0, _jquery2.default)('.store-carts-list', $listWrapper);
            var $mapBtn = (0, _jquery2.default)('.map-button', '.results-box');
            var $gridBtn = (0, _jquery2.default)('.grid-button', '.results-box');
            var $searchBtn = (0, _jquery2.default)('.search__small-button');
            var $cornerBlueBtn = (0, _jquery2.default)('.open-map__corner', $contactMapStoreList);
            var $geolocalizationBtn = (0, _jquery2.default)('.js_set-center-contact-map', '.contact-map-geo-filter');
            var $toggleBox = (0, _jquery2.default)('.toggle-box', '.wrapper-contact-form--map');
            var mapCenterDefault = { lat: 39.5, lng: -3 };
            var markersData = []; // JSON.parse(data);
            var list = (0, _jquery2.default)('.store-carts-list > li');
            var map = {};
            var DEFAULT_MAPZOOM = 10;
            var moveFormInsideList = function moveFormInsideList(insideList) {
                if (insideList) {
                    $toggleBox.addClass('mobile-form').appendTo((0, _jquery2.default)('ul.store-carts-list'));
                } else {
                    $toggleBox.removeClass('mobile-form').appendTo((0, _jquery2.default)('.wrapper-contact-form--map'));
                }
            };
            var showMap = function showMap($mapWrapper) {
                $mapBtn.addClass('active');
                $gridBtn.removeClass('active');

                $mapWrapper.addClass('show');
                if (typeof google !== 'undefined') {
                    window.google.maps.event.trigger(map, 'resize');
                }
            };
            var getMapCenter = function getMapCenter(targetElement, dataAttr, whithZoom) {
                var center = targetElement.data(dataAttr) ? targetElement.data(dataAttr).split(',') : mapCenterDefault;
                if (whithZoom) {
                    return { lat: parseFloat(center[0], 10), lng: parseFloat(center[1], 10), zoom: parseFloat(center[2], 10) };
                }
                return { lat: parseFloat(center[0], 10), lng: parseFloat(center[1], 10) };
            };
            var mapConfig = $contactMap.data('mapcenter') ? $contactMap.data('mapcenter').split(',') : mapCenterDefault;
            var mapKey = $contactMap.data('map-api-key') ? $contactMap.data('map-api-key') : 'AIzaSyAu_QxEBO0D_g5VSH-fQOQQ2x0MYF6OjZY';
            var resetHeightConf = function resetHeightConf() {
                return {
                    'mapElement': $contactMapWrapper.children().first(),
                    'toggleBox': $toggleBox.children(),
                    'uList': (0, _jquery2.default)('ul.store-carts-list'),
                    'correctHeight': $toggleBox.children().get(0).scrollHeight
                };
            };
            var moveFormBox = function moveFormBox(browserWidth) {
                // move form inside list
                if (browserWidth < 767 && $contactMapStoreList.length) {
                    if (!$mapBtn.hasClass('active')) {
                        $toggleBox.addClass('mobile-form').appendTo((0, _jquery2.default)('ul.store-carts-list'));
                    }
                } else {
                    resetHeightMap(resetHeightConf());
                    if (typeof google !== 'undefined') {
                        window.google.maps.event.trigger(map, 'resize');
                    }
                }
            };
            var $submitBtn = (0, _jquery2.default)('.toggle-box form .form-elements-wrap button[type=submit]');
            var mapRefresh = function mapRefresh(config) {
                if (typeof google !== 'undefined') {
                    window.google.maps.event.trigger(map, 'resize');
                    map.setCenter(new window.google.maps.LatLng({ lat: parseFloat(config[0]) || parseFloat(mapConfig[0]), lng: parseFloat(config[1]) || parseFloat(mapConfig[1]) }));
                }
            };
            if (!$contactMapWrapper.length) {
                return;
            }
            if (list.length) {
                var listLen = list.length;
                for (var ii = 0; ii < listLen; ii++) {
                    if (!(0, _jquery2.default)(list[ii]).hasClass('store-carts-list__item--no-results')) {
                        var geoposition = (0, _jquery2.default)(list[ii]).data('installer-geoposition');
                        var lat = geoposition ? parseFloat(geoposition.split(',')[0], 10) : '40';
                        var lon = geoposition ? parseFloat(geoposition.split(',')[1], 10) : '40';
                        var id = (0, _jquery2.default)(list[ii]).attr('id');
                        markersData.push({
                            id: id,
                            'location': { lat: lat, lon: lon },
                            'label': (0, _jquery2.default)('.title', (0, _jquery2.default)(list[ii])).text()
                        });
                    }
                }
            }
            window.episitename = document.head.querySelector('meta[name="Sitename"]').content;
            console.log(window.episitename);
            window.SAPATECH.GLOBALGOOGLEMAP = function () {
                var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : mapKey;
                var markersData = arguments[1];
                var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [mapConfig, 10];

                (0, _mapServiceMarkers.initMap)(key, markersData, config).then(function (mapObj) {
                    map = mapObj;
                    mapRefresh(config);
                });
            };

            /* GoogleMapsLoader */
            if ($contactMapWrapper.length) {
                (0, _mapServiceMarkers.initMap)(mapKey, markersData, mapConfig).then(function (mapObj) {
                    map = mapObj;
                    toggleListener(map);
                });
            }
            var handlers = function handlers() {
                var resizeHandler = function resizeHandler() {
                    var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
                    if (isMobileDevice) {
                        return false;
                    }
                    if (browserWidth < 767) {
                        moveFormInsideList(true);
                        toggleCardPagination(1, false);

                        if (!$mapBtn.hasClass('active')) {
                            // hide map
                            $contactMapWrapper.removeClass('show');
                            $listWrapper.removeClass('desktop-only');
                            $mapBtn.removeClass('active');
                            $gridBtn.addClass('active');
                            moveFormInsideList();
                            (0, _jquery2.default)('.js_custom-scroll').attr('style', ''); // update Custom Scroll
                        }
                    } else {
                        // addCustomScroll('js_custom-scroll');
                        moveFormInsideList();
                        // show map
                        $contactMapWrapper.addClass('show');
                        resetHeightMap(resetHeightConf());
                        toggleCardPagination(null, 1);
                    }
                    if (typeof google !== 'undefined') {
                        window.google.maps.event.trigger(map, 'resize');
                    }
                    updateCustomScroll('.store-carts-list.js_custom-scroll');
                    moveFormBox(browserWidth);
                };

                (0, _jquery2.default)(window).on('resize', resizeHandler).on('load', function () {
                    var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;

                    if (browserWidth >= 767 && $contactMapWrapper.length) {
                        // show map
                        // $contactMapWrapper.addClass('show');
                        // if (typeof google !== 'undefined') {
                        //   window.google.maps.event.trigger(map, 'resize');
                        //   map.setCenter(new window.google.maps.LatLng({lat: parseFloat(mapConfig[0]), lng: parseFloat(mapConfig[1])}));
                        // }
                        // toggleCardPagination(-1, 'isDesktop');
                    } else {
                        toggleCardPagination(1, false);
                        addStylesPager();
                        moveFormBox(browserWidth);
                    }
                });

                // on click map icon
                $mapBtn.on('click', function () {
                    var mapCenterNew = getMapCenter($contactMap, 'mapcenter');

                    (0, _jquery2.default)('.toggle-box', '.wrapper-contact-form--map').removeClass('toggle-box--opened');
                    showMap($contactMapWrapper);
                    moveFormInsideList();
                    $listWrapper.addClass('desktop-only');
                    if (typeof google !== 'undefined' && (0, _jquery2.default)('.contact-map').length) {
                        map.panTo(mapCenterNew);
                    }
                });

                $gridBtn.on('click', function () {
                    $mapBtn.removeClass('active');
                    $gridBtn.addClass('active');

                    $contactMapWrapper.removeClass('show');
                    $listWrapper.removeClass('desktop-only');
                    moveFormInsideList(true);
                });

                $searchBtn.on('click', function (e) {
                    e.preventDefault();
                    var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
                    var place = JSON.parse((0, _jquery2.default)(e.target).attr('data-place') || null);
                    var viewport = place ? place.viewport : null;
                    var location = place ? place.location : null;

                    if (browserWidth < 767 && $contactMapWrapper.length) {
                        // open map
                        $mapBtn.trigger('click');
                    }

                    // If the place has a geometry, then present it on a map.
                    if (!place) {
                        return;
                    }
                    if (place && viewport) {
                        map.fitBounds(viewport);
                    } else {
                        if (place && location) {
                            map.setCenter(place.geometry.location);
                        } else {
                            map.setCenter(10);
                        }
                        map.setZoom(17); // Why 17? Because it looks good.
                    }
                    // scroll to map
                    scrollTo($contactMap, $header);
                });

                $geolocalizationBtn.on('click', function (e) {
                    e.preventDefault();
                    var mapCenterCard = getMapCenter($contactMap, 'user-geoposition');
                    var mapCenterDefault = { lat: 39.5, lng: -3 };
                    var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;

                    if (browserWidth < 767 && $contactMapWrapper.length) {
                        // open map
                        $mapBtn.trigger('click');
                    }

                    // scroll to map
                    scrollTo($contactMap, $header);

                    if (!mapCenterCard) {
                        map.panTo(mapCenterDefault);
                        map.setZoom(DEFAULT_MAPZOOM);
                        return;
                    }

                    var mapCenterCardNew = getMapCenter($contactMap, 'user-geoposition', true);
                    map.panTo({ lat: mapCenterCardNew.lat, lng: mapCenterCardNew.lng });
                    map.setZoom(mapCenterCardNew.zoom);
                });

                window.SAPATECH.cornerbuttonHandler = function (e) {
                    var mapCenterCard = getMapCenter((0, _jquery2.default)(e.target).closest('li'), 'installer-geoposition');
                    var zoom = (0, _jquery2.default)(e.target).closest('ul').attr('data-contact-zoom') || DEFAULT_MAPZOOM;
                    var $toggleBox = (0, _jquery2.default)('.toggle-box');
                    if (isMobile()) {
                        return false;
                    }
                    if ($toggleBox.hasClass('toggle-box--opened')) {
                        $toggleBox.removeClass('toggle-box--opened');
                    }
                    // scroll to map		
                    scrollTo($contactMap, $header);
                    map.panTo(mapCenterCard);
                    map.setZoom(parseInt(zoom, 10));
                    return false;
                };

                $cornerBlueBtn.on('click', window.SAPATECH.cornerbuttonHandler);

                $submitBtn.on('click', function (e) {
                    e.preventDefault();

                    if (!isMobile()) {
                        setTimeout(function () {
                            resetHeightMap(resetHeightConf());
                        }, 10);
                    }
                });
            };

            handlers();
        }

        /**
         * paginatorInitTest
         */
        function paginatorInit() {
            var $body = (0, _jquery2.default)('body');
            var $footer = (0, _jquery2.default)('.footer', $body);
            var footerClsSticky = 'footer--stick-bottom';
            var totalPagerLen = (0, _jquery2.default)('.wrapper-contact-form ul .store-carts-list__item[data-include="on"]', $body).length;
            var pagerConfig = {
                ulClass: 'pager',
                activeClass: 'active',
                adjacent: 1,
                // hideIfEmpty: false,
                // scrollTop: true,
                scrollContainer: 'store-carts-list-wrapper',
                lang: 'en'
            };
            var myPager = {};

            if (!(0, _jquery2.default)('.wrapper-contact-form--map').length) {
                return;
            }
            if (isMobile()) {
                // config
                _jsPagination2.default.config(pagerConfig);

                myPager = new _jsPagination2.default(totalPagerLen, 10, function (page) {
                    var hideLast = function hideLast() {
                        return page.current === totalPagerLen;
                    };
                    var hideFirst = function hideFirst() {
                        return page.current === 1;
                    };

                    setTimeout(function () {
                        // redefine visible numbers
                        // Pagination.config({
                        //   adjacent: 2
                        // });
                        scrollTo((0, _jquery2.default)('.store-carts-list-wrapper'), $header);
                        toggleCardPagination(myPager.getCurrentPage(), false);
                        addStylesPager(hideFirst, hideLast);
                        (0, _buttonBlack.updateBodyHeigth)($body, $footer, footerClsSticky);
                    });
                }, '.pager');
            }
        }

        /**
         * Init Inspiration
         */
        function init() {
            if (!(0, _jquery2.default)('.wrapper-contact-form.wrapper-contact-form--map').length) {
                return;
            }
            contactMapInit();
            if (!isMobileDevice) {
                addCustomScroll('.js_custom-scroll_list');
            }
            paginatorInit();

            window.SAPATECH.refreshList = function () {
                paginatorInit();
            };
            window.SAPATECH.updateCustomScroll = updateCustomScroll;
        }

        /***/
    }),
/* 5 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var cls = __webpack_require__(23);
        var dom = __webpack_require__(8);

        var toInt = exports.toInt = function (x) {
            return parseInt(x, 10) || 0;
        };

        var clone = exports.clone = function (obj) {
            if (!obj) {
                return null;
            } else if (Array.isArray(obj)) {
                return obj.map(clone);
            } else if (typeof obj === 'object') {
                var result = {};
                for (var key in obj) {
                    result[key] = clone(obj[key]);
                }
                return result;
            } else {
                return obj;
            }
        };

        exports.extend = function (original, source) {
            var result = clone(original);
            for (var key in source) {
                result[key] = clone(source[key]);
            }
            return result;
        };

        exports.isEditable = function (el) {
            return dom.matches(el, "input,[contenteditable]") ||
                dom.matches(el, "select,[contenteditable]") ||
                dom.matches(el, "textarea,[contenteditable]") ||
                dom.matches(el, "button,[contenteditable]");
        };

        exports.removePsClasses = function (element) {
            var clsList = cls.list(element);
            for (var i = 0; i < clsList.length; i++) {
                var className = clsList[i];
                if (className.indexOf('ps-') === 0) {
                    cls.remove(element, className);
                }
            }
        };

        exports.outerWidth = function (element) {
            return toInt(dom.css(element, 'width')) +
                toInt(dom.css(element, 'paddingLeft')) +
                toInt(dom.css(element, 'paddingRight')) +
                toInt(dom.css(element, 'borderLeftWidth')) +
                toInt(dom.css(element, 'borderRightWidth'));
        };

        function toggleScrolling(handler) {
            return function (element, axis) {
                handler(element, 'ps--in-scrolling');
                if (typeof axis !== 'undefined') {
                    handler(element, 'ps--' + axis);
                } else {
                    handler(element, 'ps--x');
                    handler(element, 'ps--y');
                }
            };
        }

        exports.startScrolling = toggleScrolling(cls.add);

        exports.stopScrolling = toggleScrolling(cls.remove);

        exports.env = {
            isWebKit: typeof document !== 'undefined' && 'WebkitAppearance' in document.documentElement.style,
            supportsTouch: typeof window !== 'undefined' && (('ontouchstart' in window) || window.DocumentTouch && document instanceof window.DocumentTouch),
            supportsIePointer: typeof window !== 'undefined' && window.navigator.msMaxTouchPoints !== null
        };


        /***/
    }),
/* 6 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var cls = __webpack_require__(23);
        var dom = __webpack_require__(8);
        var instances = __webpack_require__(2);
        var updateScroll = __webpack_require__(7);

        function getThumbSize(i, thumbSize) {
            if (i.settings.minScrollbarLength) {
                thumbSize = Math.max(thumbSize, i.settings.minScrollbarLength);
            }
            if (i.settings.maxScrollbarLength) {
                thumbSize = Math.min(thumbSize, i.settings.maxScrollbarLength);
            }
            return thumbSize;
        }

        function updateCss(element, i) {
            var xRailOffset = { width: i.railXWidth };
            if (i.isRtl) {
                xRailOffset.left = i.negativeScrollAdjustment + element.scrollLeft + i.containerWidth - i.contentWidth;
            } else {
                xRailOffset.left = element.scrollLeft;
            }
            if (i.isScrollbarXUsingBottom) {
                xRailOffset.bottom = i.scrollbarXBottom - element.scrollTop;
            } else {
                xRailOffset.top = i.scrollbarXTop + element.scrollTop;
            }
            dom.css(i.scrollbarXRail, xRailOffset);

            var yRailOffset = { top: element.scrollTop, height: i.railYHeight };
            if (i.isScrollbarYUsingRight) {
                if (i.isRtl) {
                    yRailOffset.right = i.contentWidth - (i.negativeScrollAdjustment + element.scrollLeft) - i.scrollbarYRight - i.scrollbarYOuterWidth;
                } else {
                    yRailOffset.right = i.scrollbarYRight - element.scrollLeft;
                }
            } else {
                if (i.isRtl) {
                    yRailOffset.left = i.negativeScrollAdjustment + element.scrollLeft + i.containerWidth * 2 - i.contentWidth - i.scrollbarYLeft - i.scrollbarYOuterWidth;
                } else {
                    yRailOffset.left = i.scrollbarYLeft + element.scrollLeft;
                }
            }
            dom.css(i.scrollbarYRail, yRailOffset);

            dom.css(i.scrollbarX, { left: i.scrollbarXLeft, width: i.scrollbarXWidth - i.railBorderXWidth });
            dom.css(i.scrollbarY, { top: i.scrollbarYTop, height: i.scrollbarYHeight - i.railBorderYWidth });
        }

        module.exports = function (element) {
            var i = instances.get(element);

            i.containerWidth = element.clientWidth;
            i.containerHeight = element.clientHeight;
            i.contentWidth = element.scrollWidth;
            i.contentHeight = element.scrollHeight;

            var existingRails;
            if (!element.contains(i.scrollbarXRail)) {
                existingRails = dom.queryChildren(element, '.ps__scrollbar-x-rail');
                if (existingRails.length > 0) {
                    existingRails.forEach(function (rail) {
                        dom.remove(rail);
                    });
                }
                dom.appendTo(i.scrollbarXRail, element);
            }
            if (!element.contains(i.scrollbarYRail)) {
                existingRails = dom.queryChildren(element, '.ps__scrollbar-y-rail');
                if (existingRails.length > 0) {
                    existingRails.forEach(function (rail) {
                        dom.remove(rail);
                    });
                }
                dom.appendTo(i.scrollbarYRail, element);
            }

            if (!i.settings.suppressScrollX && i.containerWidth + i.settings.scrollXMarginOffset < i.contentWidth) {
                i.scrollbarXActive = true;
                i.railXWidth = i.containerWidth - i.railXMarginWidth;
                i.railXRatio = i.containerWidth / i.railXWidth;
                i.scrollbarXWidth = getThumbSize(i, _.toInt(i.railXWidth * i.containerWidth / i.contentWidth));
                i.scrollbarXLeft = _.toInt((i.negativeScrollAdjustment + element.scrollLeft) * (i.railXWidth - i.scrollbarXWidth) / (i.contentWidth - i.containerWidth));
            } else {
                i.scrollbarXActive = false;
            }

            if (!i.settings.suppressScrollY && i.containerHeight + i.settings.scrollYMarginOffset < i.contentHeight) {
                i.scrollbarYActive = true;
                i.railYHeight = i.containerHeight - i.railYMarginHeight;
                i.railYRatio = i.containerHeight / i.railYHeight;
                i.scrollbarYHeight = getThumbSize(i, _.toInt(i.railYHeight * i.containerHeight / i.contentHeight));
                i.scrollbarYTop = _.toInt(element.scrollTop * (i.railYHeight - i.scrollbarYHeight) / (i.contentHeight - i.containerHeight));
            } else {
                i.scrollbarYActive = false;
            }

            if (i.scrollbarXLeft >= i.railXWidth - i.scrollbarXWidth) {
                i.scrollbarXLeft = i.railXWidth - i.scrollbarXWidth;
            }
            if (i.scrollbarYTop >= i.railYHeight - i.scrollbarYHeight) {
                i.scrollbarYTop = i.railYHeight - i.scrollbarYHeight;
            }

            updateCss(element, i);

            if (i.scrollbarXActive) {
                cls.add(element, 'ps--active-x');
            } else {
                cls.remove(element, 'ps--active-x');
                i.scrollbarXWidth = 0;
                i.scrollbarXLeft = 0;
                updateScroll(element, 'left', 0);
            }
            if (i.scrollbarYActive) {
                cls.add(element, 'ps--active-y');
            } else {
                cls.remove(element, 'ps--active-y');
                i.scrollbarYHeight = 0;
                i.scrollbarYTop = 0;
                updateScroll(element, 'top', 0);
            }
        };


        /***/
    }),
/* 7 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var instances = __webpack_require__(2);

        var createDOMEvent = function (name) {
            var event = document.createEvent("Event");
            event.initEvent(name, true, true);
            return event;
        };

        module.exports = function (element, axis, value) {
            if (typeof element === 'undefined') {
                throw 'You must provide an element to the update-scroll function';
            }

            if (typeof axis === 'undefined') {
                throw 'You must provide an axis to the update-scroll function';
            }

            if (typeof value === 'undefined') {
                throw 'You must provide a value to the update-scroll function';
            }

            if (axis === 'top' && value <= 0) {
                element.scrollTop = value = 0; // don't allow negative scroll
                element.dispatchEvent(createDOMEvent('ps-y-reach-start'));
            }

            if (axis === 'left' && value <= 0) {
                element.scrollLeft = value = 0; // don't allow negative scroll
                element.dispatchEvent(createDOMEvent('ps-x-reach-start'));
            }

            var i = instances.get(element);

            if (axis === 'top' && value >= i.contentHeight - i.containerHeight) {
                // don't allow scroll past container
                value = i.contentHeight - i.containerHeight;
                if (value - element.scrollTop <= 1) {
                    // mitigates rounding errors on non-subpixel scroll values
                    value = element.scrollTop;
                } else {
                    element.scrollTop = value;
                }
                element.dispatchEvent(createDOMEvent('ps-y-reach-end'));
            }

            if (axis === 'left' && value >= i.contentWidth - i.containerWidth) {
                // don't allow scroll past container
                value = i.contentWidth - i.containerWidth;
                if (value - element.scrollLeft <= 1) {
                    // mitigates rounding errors on non-subpixel scroll values
                    value = element.scrollLeft;
                } else {
                    element.scrollLeft = value;
                }
                element.dispatchEvent(createDOMEvent('ps-x-reach-end'));
            }

            if (i.lastTop === undefined) {
                i.lastTop = element.scrollTop;
            }

            if (i.lastLeft === undefined) {
                i.lastLeft = element.scrollLeft;
            }

            if (axis === 'top' && value < i.lastTop) {
                element.dispatchEvent(createDOMEvent('ps-scroll-up'));
            }

            if (axis === 'top' && value > i.lastTop) {
                element.dispatchEvent(createDOMEvent('ps-scroll-down'));
            }

            if (axis === 'left' && value < i.lastLeft) {
                element.dispatchEvent(createDOMEvent('ps-scroll-left'));
            }

            if (axis === 'left' && value > i.lastLeft) {
                element.dispatchEvent(createDOMEvent('ps-scroll-right'));
            }

            if (axis === 'top' && value !== i.lastTop) {
                element.scrollTop = i.lastTop = value;
                element.dispatchEvent(createDOMEvent('ps-scroll-y'));
            }

            if (axis === 'left' && value !== i.lastLeft) {
                element.scrollLeft = i.lastLeft = value;
                element.dispatchEvent(createDOMEvent('ps-scroll-x'));
            }

        };


        /***/
    }),
/* 8 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var DOM = {};

        DOM.e = function (tagName, className) {
            var element = document.createElement(tagName);
            element.className = className;
            return element;
        };

        DOM.appendTo = function (child, parent) {
            parent.appendChild(child);
            return child;
        };

        function cssGet(element, styleName) {
            return window.getComputedStyle(element)[styleName];
        }

        function cssSet(element, styleName, styleValue) {
            if (typeof styleValue === 'number') {
                styleValue = styleValue.toString() + 'px';
            }
            element.style[styleName] = styleValue;
            return element;
        }

        function cssMultiSet(element, obj) {
            for (var key in obj) {
                var val = obj[key];
                if (typeof val === 'number') {
                    val = val.toString() + 'px';
                }
                element.style[key] = val;
            }
            return element;
        }

        DOM.css = function (element, styleNameOrObject, styleValue) {
            if (typeof styleNameOrObject === 'object') {
                // multiple set with object
                return cssMultiSet(element, styleNameOrObject);
            } else {
                if (typeof styleValue === 'undefined') {
                    return cssGet(element, styleNameOrObject);
                } else {
                    return cssSet(element, styleNameOrObject, styleValue);
                }
            }
        };

        DOM.matches = function (element, query) {
            if (typeof element.matches !== 'undefined') {
                return element.matches(query);
            } else {
                if (typeof element.matchesSelector !== 'undefined') {
                    return element.matchesSelector(query);
                } else if (typeof element.webkitMatchesSelector !== 'undefined') {
                    return element.webkitMatchesSelector(query);
                } else if (typeof element.mozMatchesSelector !== 'undefined') {
                    return element.mozMatchesSelector(query);
                } else if (typeof element.msMatchesSelector !== 'undefined') {
                    return element.msMatchesSelector(query);
                }
            }
        };

        DOM.remove = function (element) {
            if (typeof element.remove !== 'undefined') {
                element.remove();
            } else {
                if (element.parentNode) {
                    element.parentNode.removeChild(element);
                }
            }
        };

        DOM.queryChildren = function (element, selector) {
            return Array.prototype.filter.call(element.childNodes, function (child) {
                return DOM.matches(child, selector);
            });
        };

        module.exports = DOM;


        /***/
    }),
/* 9 */
/***/ (function (module, exports, __webpack_require__) {

        var isObject = __webpack_require__(21);
        module.exports = function (it) {
            if (!isObject(it)) throw TypeError(it + ' is not an object!');
            return it;
        };

        /***/
    }),
/* 10 */
/***/ (function (module, exports, __webpack_require__) {

        var dP = __webpack_require__(22)
            , createDesc = __webpack_require__(41);
        module.exports = __webpack_require__(13) ? function (object, key, value) {
            return dP.f(object, key, createDesc(1, value));
        } : function (object, key, value) {
            object[key] = value;
            return object;
        };

        /***/
    }),
/* 11 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.toggler = toggler;
        exports.getMapData = getMapData;
        exports.updateModalInfo = updateModalInfo;
        exports.projectsCardListenr = projectsCardListenr;
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _contactMap = __webpack_require__(4);

        var _slider = __webpack_require__(18);

        var slider = _interopRequireWildcard(_slider);

        function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Toggle social share popover
         */
        function toggler($wrapper, openedCls) {
            var $socialWrapper = $wrapper; // $('.share-box ');
            var searchOpenedCls = openedCls; // 'share-box--opened';

            $socialWrapper.toggleClass(searchOpenedCls);
        }

        /**
         * getData
         */
        function getMapData(selectorEl, dataName) {
            return (0, _jquery2.default)(selectorEl).data(dataName);
        }

        /**
         * updateModalInfo
         */
        function updateModalInfo(itemId) {
            var siteUrl = function siteUrl() {
                var host = window.location.host,
                    localhost = /(localhost:3000|127\.0\.0\.1)+/ig;
                return localhost.test(host) ? 'https://technal-professional.sapa-001.projects.epam.com' : '';
            };
            var data = {
                title: '.title',
                category: '.subtitle',
                country: '.address',
                office: '.office',
                description: '.description',
                tagsBox: '.tags-wrapper',
                productsLinks: '.items-details-list',
                slider: '.slider-modal .slider',
                sliderLocation: '.slider-location',
                modalBox: '#modal-item-info',
                productLink: '.productLink'
            };
            var productLinkText = getMapData('#projects', 'gotoproduct');
            var cartsData = function cartsData() {
                var normalizedObj = {};
                getMapData('#projects', 'projects').forEach(function (item) {
                    normalizedObj[item.Id] = item;
                });
                return normalizedObj;
            };
            var addArrayEl = function addArrayEl(arr, wrapper) {
                (0, _jquery2.default)(wrapper).empty();
                arr.forEach(function (item) {
                    (0, _jquery2.default)(wrapper).append('<div class="tag">' + item + '</div>');
                });
            };
            var addArrayLinks = function addArrayLinks(arr, wrapper) {
                var li = [];
                var titlePrimary = '';
                (0, _jquery2.default)(wrapper).empty();
                arr.forEach(function (item) {
                    if (item.Name) {
                        titlePrimary = item.Name;
                    }
                    if (item.Line && item.Name) {
                        titlePrimary = item.Line + ', ' + item.Name;
                    }
                    li.push('<li class="items-details-list items-details-list__item">\n        <h2 class="title-primary list-title ">' + titlePrimary + '</h2>\n        <a class="button-black list-button  productLink" href="' + item.Url + '">' + productLinkText + '</a>\n      </li>');
                });
                (0, _jquery2.default)(wrapper).append(li.join(''));
            };
            var addArraySlider = function addArraySlider(arr, wrapper) {
                var li = [];
                (0, _jquery2.default)(wrapper).empty();
                arr.forEach(function (item) {
                    li.push('\n        <div class="slide slide--modal">\n          <img src="' + (siteUrl() + item.Url) + '" data-original="' + (siteUrl() + item.Url) + '" class="slide__image lazy" alt="' + item.AltText + '" />\n        </div>\n      ');
                });
                (0, _jquery2.default)(wrapper).append(li.join(''));
                (0, _jquery2.default)(wrapper).append('<div class="slider-navigation slider-navigation--modal"></div>');
            };
            var updateShareBox = function updateShareBox(itemObj, wrapper) {
                var listObj = {
                    'short-url': itemObj.AbsoluteUrl,
                    'title': itemObj.Name,
                    'image': itemObj.TeaserImageAbsoluteUrl,
                    'message': itemObj.Name + ' - ' + itemObj.AbsoluteUrl
                };
                (0, _jquery2.default)('.share-box__link', wrapper).each(function (idx, item) {
                    for (var linkDataAttr in listObj) {
                        if (Object.prototype.hasOwnProperty.call(listObj, linkDataAttr)) {
                            (0, _jquery2.default)(item).attr('data-' + linkDataAttr, listObj[linkDataAttr]);
                        }
                    }
                });
            };
            var item = cartsData();
            var drawElement = function drawElement(el, dataOption) {
                var item = dataOption.item,
                    field = dataOption.field,
                    _dataOption$isToUpper = dataOption.isToUpperCase,
                    isToUpperCase = _dataOption$isToUpper === undefined ? false : _dataOption$isToUpper;
                // check if data is not empty

                if (field.length === 1) {
                    if (item[field[0]]) {
                        if (isToUpperCase) {
                            el.text('' + item[field[0]].toUpperCase());
                        } else {
                            el.text('' + item[field[0]]);
                        }
                    } else {
                        el.text('');
                    }
                } else if (field.length === 2) {
                    if (item[field[0]] && item[field[1]]) {
                        el.text(item[field[0]] + ', ' + item[field[1]]);
                    } else {
                        el.text('');
                    }
                }
            };

            var _itemId = itemId;

            if (_itemId.indexOf('\u1F595') !== -1) {
                _itemId = _itemId.replace('\u1F595', '');
            }

            drawElement((0, _jquery2.default)(data.title, data.modalBox), { item: item[_itemId], field: ['Name'], isToUpperCase: true });
            drawElement((0, _jquery2.default)(data.category, data.modalBox), { item: item[_itemId], field: ['Category'] });
            drawElement((0, _jquery2.default)(data.country, data.modalBox), { item: item[_itemId], field: ['City', 'Country'] });
            drawElement((0, _jquery2.default)(data.creator, data.modalBox), { item: item[_itemId], field: ['Architect'] });
            if ((0, _jquery2.default)(data.description, data.modalBox)) {
                (0, _jquery2.default)(data.description, data.modalBox).html(_jquery2.default.parseHTML(item[_itemId].Description)); // render html
            } else {
                (0, _jquery2.default)(data.description, data.modalBox).html('');
            }
            addArrayEl(item[_itemId].Tags, data.tagsBox);
            addArrayLinks(item[_itemId].ProductsLinks, data.productsLinks);
            addArraySlider(item[_itemId].AllImages, data.slider);

            if (item[_itemId].Location) {
                (0, _jquery2.default)(data.sliderLocation, data.modalBox).attr('data-location', item[_itemId].Location).show();
            } else {
                (0, _jquery2.default)(data.sliderLocation, data.modalBox).hide();
            }
            updateShareBox(item[_itemId], data.shareBox);
        }

        /**
         * Listenr for project Card
         * @param itemId - {string}
         */
        function projectsCardListenr(itemId, modalOverflowCls) {
            var isMobileModal = function isMobileModal() {
                var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
                var elToHide = ['.inspiration-carts-list', '.inspiration-filter'];

                elToHide.forEach(function (item) {
                    if (browserWidth < 767 && (0, _jquery2.default)('body').hasClass(modalOverflowCls)) {
                        (0, _jquery2.default)(item).hide();
                    } else {
                        (0, _jquery2.default)(item).show();
                    }
                });
            };

            slider.destroy();
            updateModalInfo(itemId);
            (0, _jquery2.default)('#modal-item-info').show();
            (0, _jquery2.default)('body').addClass(modalOverflowCls);
            isMobileModal();
            (0, _contactMap.addCustomScroll)('.modal-item-info');
            setTimeout(function () {
                return slider.init();
            });
        }

        /**
         * modal
         */
        function init() {
            var $aCartsList = (0, _jquery2.default)('.inspiration-carts-list');
            var $gridWrapper = (0, _jquery2.default)('.projects-list', $aCartsList);
            var $modal = (0, _jquery2.default)('#modal-item-info');
            var closeBtnCls = '#modal-item-info .js_close';
            var modalSocialBtnCls = '.modal-share-box__button';
            var modalSocialBtnCloseCls = 'modal-share-box__button--close';
            var modalOverflow = 'modal-open show-overflow';
            var projectCardCls = '.project-card';

            /**
             * check if modal opened in mobile screen
             */
            function isMobileModal() {
                var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
                var elToHide = ['.inspiration-carts-list', '.inspiration-filter'];

                elToHide.forEach(function (item) {
                    if (browserWidth < 767 && (0, _jquery2.default)('body').hasClass(modalOverflow)) {
                        (0, _jquery2.default)(item).hide();
                    } else {
                        (0, _jquery2.default)(item).show();
                    }
                });
            }

            isMobileModal();

            $gridWrapper.on('click', projectCardCls, function (e) {
                var itemId = (0, _jquery2.default)(e.target).closest('.project-card').attr('id');
                projectsCardListenr(itemId, modalOverflow);
            });

            // When the user clicks on <span> (x), close the modal
            (0, _jquery2.default)(document).on('click', closeBtnCls, function () {
                $modal.hide();
                (0, _jquery2.default)('body').removeClass(modalOverflow);
                isMobileModal();
                slider.destroy();
                // check one more listener for closeBtnCls in 'carts-list-toggle.js' which is update map
            });

            // When the user clicks anywhere outside of the modal, close it
            (0, _jquery2.default)(window).on('click', function (event) {
                if (event.target === $modal.get(0)) {
                    $modal.hide();
                    (0, _jquery2.default)('body').removeClass(modalOverflow);
                    isMobileModal();
                    slider.destroy();
                }
            }).on('resize', function () {
                return isMobileModal();
            });

            (0, _jquery2.default)(document).on('click', modalSocialBtnCls, function () {
                toggler((0, _jquery2.default)('.share-box ', '.modal-share-box'), 'share-box--opened');
                (0, _jquery2.default)(modalSocialBtnCls).toggleClass(modalSocialBtnCloseCls);
            });
        }

        /***/
    }),
/* 12 */
/***/ (function (module, exports) {

        var core = module.exports = { version: '2.4.0' };
        if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef

        /***/
    }),
/* 13 */
/***/ (function (module, exports, __webpack_require__) {

        // Thank's IE8 for his funny defineProperty
        module.exports = !__webpack_require__(37)(function () {
            return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
        });

        /***/
    }),
/* 14 */
/***/ (function (module, exports) {

        var hasOwnProperty = {}.hasOwnProperty;
        module.exports = function (it, key) {
            return hasOwnProperty.call(it, key);
        };

        /***/
    }),
/* 15 */
/***/ (function (module, exports) {

        module.exports = {};

        /***/
    }),
/* 16 */
/***/ (function (module, exports, __webpack_require__) {

        var global = __webpack_require__(3)
            , hide = __webpack_require__(10)
            , has = __webpack_require__(14)
            , SRC = __webpack_require__(32)('src')
            , TO_STRING = 'toString'
            , $toString = Function[TO_STRING]
            , TPL = ('' + $toString).split(TO_STRING);

        __webpack_require__(12).inspectSource = function (it) {
            return $toString.call(it);
        };

        (module.exports = function (O, key, val, safe) {
            var isFunction = typeof val == 'function';
            if (isFunction) has(val, 'name') || hide(val, 'name', key);
            if (O[key] === val) return;
            if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
            if (O === global) {
                O[key] = val;
            } else {
                if (!safe) {
                    delete O[key];
                    hide(O, key, val);
                } else {
                    if (O[key]) O[key] = val;
                    else hide(O, key, val);
                }
            }
            // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
        })(Function.prototype, TO_STRING, function toString() {
            return typeof this == 'function' && this[SRC] || $toString.call(this);
        });

        /***/
    }),
/* 17 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.updateBodyHeigth = updateBodyHeigth;
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _selectric = __webpack_require__(46);

        var _selectric2 = _interopRequireDefault(_selectric);

        var _select = __webpack_require__(34);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * update Body Heigth
         */
        function updateBodyHeigth($body, $footer, footerClsSticky) {
            if ($body.hasClass('edit-mode') || (0, _jquery2.default)('.slide').hasClass('slide--full-height')) {
                return;
            }
            $footer.removeClass(footerClsSticky);
            $body.css('height', 'auto');
            setTimeout(function () {
                $body.css('height', (0, _jquery2.default)(document).height());
                $footer.removeClass(footerClsSticky);
                if ($body.height() <= (0, _jquery2.default)(window).height()) {
                    $footer.addClass(footerClsSticky);
                }
            }, 100);
        }

        /**
         * On form change toggle reset button.
         * Reset button click handler
         */
        function hideResetButton() {
            var $body = (0, _jquery2.default)('body');
            var $footer = (0, _jquery2.default)('.footer', $body);
            var footerClsSticky = 'footer--stick-bottom';

            var $form = (0, _jquery2.default)('.wrapper form', $body);
            var $resetBtn = $form.find('[type=reset]');
            var $customSelect = $form.find(_select.selectCls);

            if ((0, _jquery2.default)('.news-filters-wrapper form').length > 0) {
                $form = (0, _jquery2.default)('.news-filters-wrapper form');
                $resetBtn = $form.find('[type=reset]');
                $customSelect = $form.find(_select.selectCls);
            }

            if (!$resetBtn.length) {
                return;
            }

            $form.on('change', function () {
                if ($form.serialize() === '') {
                    $resetBtn.hide();
                    updateBodyHeigth($body, $footer, footerClsSticky);
                    return;
                }

                $resetBtn.show();
                updateBodyHeigth($body, $footer, footerClsSticky);
            });

            $resetBtn.on('click', function () {
                updateBodyHeigth($body, $footer, footerClsSticky);
                if (_selectric2.default && $customSelect.length) {
                    $customSelect.val('').selectric('refresh');
                }

                $resetBtn.hide();
            });

            (0, _jquery2.default)(window).on('unload', function () {
                $resetBtn.trigger('click');
                $resetBtn.hide();
            });
        }

        /**
         * Init button
         */
        function init() {
            hideResetButton();
        }

        /***/
    }),
/* 18 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.setBgImgForIe = setBgImgForIe;
        exports.init = init;
        exports.destroy = destroy;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _slickCarousel = __webpack_require__(47);

        var _slickCarousel2 = _interopRequireDefault(_slickCarousel);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var $slider = (0, _jquery2.default)('.slider');

        /**
         * setBgImgForIe
         */
        function setBgImgForIe(el) {
            var ie11 = navigator.userAgent.match(/rv:11.0/i);
            var Edge = window.navigator.userAgent.indexOf('Edge');
            var setBgObjectFit = function setBgObjectFit() {
                var $container = (0, _jquery2.default)(this),
                    imgUrl = $container.find('img').prop('src');
                if (imgUrl) {
                    $container.css('backgroundImage', 'url(' + imgUrl + ')').addClass('compat-object-fit');
                }
            };

            if (ie11 || Edge) {
                (0, _jquery2.default)('.js_crop-img', el).parent().each(setBgObjectFit);
            }
        }

        /**
         * Init slider
         */
        function init() {

            //var $window = (0, _jquery2.default)(window);

            var ht, $simpleSlider = (0, _jquery2.default)('.simple-slider2');

            if ($simpleSlider.length > 0) {
                $simpleSlider.slick({
                    dots: true,
                    arrows: false,
                    speed: 400,
                    autoplay: true,
                    infinite: false,
                    slidesToShow: 1,
                    slidesToScroll: 1,
                    cssEase: 'ease-in-out'
                });

                equalizeSliderHeight();
                //$window.on('resize', equalizeSliderHeight);
            }

            function equalizeSliderHeight() {
                //enquire.register("screen and (min-width:768px)", {
                //    match: function () {
                //        ht = $simpleSlider.next('.generic-block').height();
                //        $simpleSlider.height(ht);
                //    }
                //});

                //enquire.register("screen and (max-width:767px)", {
                //    match: function () {
                //        $simpleSlider.height(300);
                //    }
                //});
            }



            if (!_slickCarousel2.default || !$slider || !$slider.length) {
                return;
            }

            $slider.slick({
                slide: '.slide',
                dots: true,
                appendArrows: '.slider-navigation',
                appendDots: '.slider-navigation',
                fade: true,
                infinite: true,
                autoplay: true,
                pauseOnFocus: false,
                pauseOnHover: false,
                autoplaySpeed: 4000
            });

            setBgImgForIe($slider);
        }

        /**
         * Destroy slider
         */
        function destroy() {
            if (!_slickCarousel2.default || !$slider || !$slider.length) {
                return;
            }

            $slider.slick('unslick');
        }

        /***/
    }),
/* 19 */
/***/ (function (module, exports) {

        var toString = {}.toString;

        module.exports = function (it) {
            return toString.call(it).slice(8, -1);
        };

        /***/
    }),
/* 20 */
/***/ (function (module, exports, __webpack_require__) {

        // optional / simple context binding
        var aFunction = __webpack_require__(24);
        module.exports = function (fn, that, length) {
            aFunction(fn);
            if (that === undefined) return fn;
            switch (length) {
                case 1: return function (a) {
                    return fn.call(that, a);
                };
                case 2: return function (a, b) {
                    return fn.call(that, a, b);
                };
                case 3: return function (a, b, c) {
                    return fn.call(that, a, b, c);
                };
            }
            return function (/* ...args */) {
                return fn.apply(that, arguments);
            };
        };

        /***/
    }),
/* 21 */
/***/ (function (module, exports) {

        module.exports = function (it) {
            return typeof it === 'object' ? it !== null : typeof it === 'function';
        };

        /***/
    }),
/* 22 */
/***/ (function (module, exports, __webpack_require__) {

        var anObject = __webpack_require__(9)
            , IE8_DOM_DEFINE = __webpack_require__(73)
            , toPrimitive = __webpack_require__(93)
            , dP = Object.defineProperty;

        exports.f = __webpack_require__(13) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
            anObject(O);
            P = toPrimitive(P, true);
            anObject(Attributes);
            if (IE8_DOM_DEFINE) try {
                return dP(O, P, Attributes);
            } catch (e) { /* empty */ }
            if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
            if ('value' in Attributes) O[P] = Attributes.value;
            return O;
        };

        /***/
    }),
/* 23 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        function oldAdd(element, className) {
            var classes = element.className.split(' ');
            if (classes.indexOf(className) < 0) {
                classes.push(className);
            }
            element.className = classes.join(' ');
        }

        function oldRemove(element, className) {
            var classes = element.className.split(' ');
            var idx = classes.indexOf(className);
            if (idx >= 0) {
                classes.splice(idx, 1);
            }
            element.className = classes.join(' ');
        }

        exports.add = function (element, className) {
            if (element.classList) {
                element.classList.add(className);
            } else {
                oldAdd(element, className);
            }
        };

        exports.remove = function (element, className) {
            if (element.classList) {
                element.classList.remove(className);
            } else {
                oldRemove(element, className);
            }
        };

        exports.list = function (element) {
            if (element.classList) {
                return Array.prototype.slice.apply(element.classList);
            } else {
                return element.className.split(' ');
            }
        };


        /***/
    }),
/* 24 */
/***/ (function (module, exports) {

        module.exports = function (it) {
            if (typeof it != 'function') throw TypeError(it + ' is not a function!');
            return it;
        };

        /***/
    }),
/* 25 */
/***/ (function (module, exports, __webpack_require__) {

        // getting tag from 19.1.3.6 Object.prototype.toString()
        var cof = __webpack_require__(19)
            , TAG = __webpack_require__(1)('toStringTag')
            // ES3 wrong here
            , ARG = cof(function () { return arguments; }()) == 'Arguments';

        // fallback for IE11 Script Access Denied error
        var tryGet = function (it, key) {
            try {
                return it[key];
            } catch (e) { /* empty */ }
        };

        module.exports = function (it) {
            var O, T, B;
            return it === undefined ? 'Undefined' : it === null ? 'Null'
                // @@toStringTag case
                : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
                    // builtinTag case
                    : ARG ? cof(O)
                        // ES3 arguments fallback
                        : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
        };

        /***/
    }),
/* 26 */
/***/ (function (module, exports) {

        // 7.2.1 RequireObjectCoercible(argument)
        module.exports = function (it) {
            if (it == undefined) throw TypeError("Can't call method on  " + it);
            return it;
        };

        /***/
    }),
/* 27 */
/***/ (function (module, exports, __webpack_require__) {

        var isObject = __webpack_require__(21)
            , document = __webpack_require__(3).document
            // in old IE typeof document.createElement is 'object'
            , is = isObject(document) && isObject(document.createElement);
        module.exports = function (it) {
            return is ? document.createElement(it) : {};
        };

        /***/
    }),
/* 28 */
/***/ (function (module, exports, __webpack_require__) {

        var def = __webpack_require__(22).f
            , has = __webpack_require__(14)
            , TAG = __webpack_require__(1)('toStringTag');

        module.exports = function (it, tag, stat) {
            if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
        };

        /***/
    }),
/* 29 */
/***/ (function (module, exports, __webpack_require__) {

        var shared = __webpack_require__(42)('keys')
            , uid = __webpack_require__(32);
        module.exports = function (key) {
            return shared[key] || (shared[key] = uid(key));
        };

        /***/
    }),
/* 30 */
/***/ (function (module, exports) {

        // 7.1.4 ToInteger
        var ceil = Math.ceil
            , floor = Math.floor;
        module.exports = function (it) {
            return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
        };

        /***/
    }),
/* 31 */
/***/ (function (module, exports, __webpack_require__) {

        // to indexed object, toObject with fallback for non-array-like ES3 strings
        var IObject = __webpack_require__(75)
            , defined = __webpack_require__(26);
        module.exports = function (it) {
            return IObject(defined(it));
        };

        /***/
    }),
/* 32 */
/***/ (function (module, exports) {

        var id = 0
            , px = Math.random();
        module.exports = function (key) {
            return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
        };

        /***/
    }),
/* 33 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });

        var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

        exports.drawMap = drawMap;
        exports.initMap = initMap;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _promise = __webpack_require__(68);

        var _promise2 = _interopRequireDefault(_promise);

        var _googleMaps = __webpack_require__(102);

        var _googleMaps2 = _interopRequireDefault(_googleMaps);

        var _inspirationModal = __webpack_require__(11);

        var _contactMap = __webpack_require__(4);

        var _slider = __webpack_require__(18);

        var slider = _interopRequireWildcard(_slider);

        function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var ie11 = navigator.userAgent.match(/rv:11.0/i);
        var isMobileOrTablet = /iPhone|iPad|iPod|Android|blackberry|nokia|opera mini|windows mobile|windows phone|iemobile/i.test(navigator.userAgent);
        var DEFAULT_MAP_CENTER = {
            lat: 39.5,
            lng: -3
        };
        var DEFAULT_ZOOM = 7;
        var MAP_OPTIONS = {
            disableDefaultUI: true,
            zoomControl: true,
            mapTypeControl: true,
            gestureHandling: isMobileOrTablet ? 'cooperative' : 'greedy',
            styles: [{
                'featureType': 'administrative',
                'elementType': 'geometry',
                'stylers': [{
                    'visibility': 'off'
                }]
            }, {
                'featureType': 'administrative.neighborhood',
                'stylers': [{
                    'visibility': 'off'
                }]
            }, {
                'featureType': 'poi',
                'stylers': [{
                    'visibility': 'off'
                }]
            }, {
                'featureType': 'road',
                'elementType': 'labels.icon',
                'stylers': [{
                    'visibility': 'off'
                }]
            }, {
                'featureType': 'transit',
                'stylers': [{
                    'visibility': 'off'
                }]
            }]
        };
        var $list = (0, _jquery2.default)('.store-carts-list');
        var $listInspiration = (0, _jquery2.default)('.projects-list');
        var host = window.location.host;
        var localhost = /(localhost:3000|127\.0\.0\.1|technal-professional.sapa-001.projects.epam.com)+/ig;
        var markers = [];

        var siteURL = function siteURL() {
            if (window.SAPATECHBACKEND && window.SAPATECHBACKEND.assetsUrl) {
                return window.SAPATECHBACKEND.assetsUrl;
            } else {
                // get icon for localhost or prototype
                return !localhost.test(host) ? 'https://technal-professional.sapa-001.projects.epam.com/Prototype/assets/' : '';
            }
        };

        /**
         * isMobile
         * @returns {boolean}
         */
        function isMobile() {
            var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
            return browserWidth <= 767;
        }

        /**
         * initAutocomplete
         */
        function initAutocomplete(google) {
            var input = document.getElementById('address-input');
            var $searchBtn = (0, _jquery2.default)('.search__small-button');

            if (!input) {
                return;
            }

            var options = {
                types: ['geocode'],
            };

            if (window.ISOCODE) {
                options.componentRestrictions = { country: window.ISOCODE };
            }
            var autocomplete = new google.maps.places.Autocomplete(input,
                options);

            autocomplete.addListener('place_changed', function placeChanged() {
                var place = autocomplete.getPlace();
                var viewport = place.geometry.viewport;
                var location = place.geometry.location;
                $searchBtn.data('place', JSON.stringify({ viewport: viewport, location: location }));
                $searchBtn.attr('data-place', JSON.stringify({ viewport: viewport, location: location }));
            });
        }

        /**
         * check if modal opened in mobile screen
         */
        function isMobileModalMap() {
            var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
            var elToHide = ['.inspiration-carts-list', '.inspiration-filter'];
            var modalOverflow = 'modal-open';

            elToHide.forEach(function (item) {
                if (browserWidth <= 767 && (0, _jquery2.default)('body').hasClass(modalOverflow)) {
                    (0, _jquery2.default)(item).hide();
                    (0, _jquery2.default)('.map').removeClass('show');
                    (0, _jquery2.default)('body').addClass('show-overflow');
                } else {
                    (0, _jquery2.default)(item).show();
                    (0, _jquery2.default)('body').removeClass('show-overflow');
                }
            });
        }

        var toggleFormOnMobileMap = function toggleFormOnMobileMap(titleText) {
            var $toggleBox = (0, _jquery2.default)('.toggle-box', '.wrapper-contact-form--map');
            if ($toggleBox.hasClass('toggle-box--opened')) {
                $toggleBox.removeClass('toggle-box--opened');
            }
            $toggleBox.addClass('toggle-box--opened');

            if ($toggleBox.hasClass('toggle-box--opened') && (0, _jquery2.default)('.contact-name', $toggleBox).text() === titleText) {
                $toggleBox.removeClass('toggle-box--opened');
            }
        };

        /**
         * Draw info window tooltip
         * @param item - Tooltip object
         * @param map - Google map instance
         * @param google - Google instance
         */
        function drawPin(item, map, google) {
            var myLatLng = new google.maps.LatLng(item.location.lat, item.location.lon);
            var iconHover = siteURL() + 'location-icon-black.svg';
            var designPreference = $("#globalInfo").data("design-preference");

            var icon;

            if (designPreference == "ProfessionalSapa") {
                icon = siteURL() + 'location-icon-green.svg';
            }

            else if (designPreference == "ProfessionalDomal") {
                icon = siteURL() + 'location-icon-domal.png';
            }

            else {
                icon = siteURL() + 'location-icon-blue.svg';
            }



            var marker = new google.maps.Marker({
                position: myLatLng,
                map: map,
                icon: icon,
                customId: item.id + '\u1F595'
            });

            var listener = function listener() {
                var $modal = (0, _jquery2.default)('#modal-item-info');
                var itemId = this.customId;
                slider.destroy();
                (0, _inspirationModal.updateModalInfo)(itemId);
                // ignore for contact-page
                if ($modal.length) {
                    $modal.show();
                    (0, _jquery2.default)('body').addClass('modal-open');
                    (0, _contactMap.addCustomScroll)('.modal-item-info');
                    isMobileModalMap();
                    setTimeout(function () {
                        return slider.init();
                    });
                }
                return false;
            };

            // contact-map page listener
            var markerListener = function markerListener() {
                var $list = (0, _jquery2.default)('.store-carts-list');
                var itemId = (0, _jquery2.default)('#' + item.id);
                var $toggleBox = (0, _jquery2.default)('.toggle-box', '.wrapper-contact-form--map');
                var formContactorName = (0, _jquery2.default)('.contact-name', $toggleBox);
                var $itemTitle = (0, _jquery2.default)('.title', itemId).text();

                // ignore for other-pages
                if ($list.length) {

                    if (isMobile()) {

                        if (window.episitename === "Domal") {
                            // get url 
                            // window.location
                            var url = (0, _jquery2.default)('a.button-black', itemId).prop('href');
                            window.open(url, "_blank");
                        }
                        else {
                            if ($toggleBox.length) {
                                toggleFormOnMobileMap($itemTitle);
                                formContactorName.text($itemTitle);
                                if ($toggleBox.hasClass('toggle-box--opened')) {
                                    (0, _contactMap.scrollTo)($toggleBox, (0, _jquery2.default)('.header'));
                                }
                            }
                        }
                    } else {
                        (0, _contactMap.scrollTo)($list, (0, _jquery2.default)('.header'), 500);
                        $list.stop().animate({
                            scrollTop: parseInt(itemId.offset().top, 10) - $list.offset().top + $list.scrollTop()
                        }, 1000);
                        (0, _jquery2.default)('li.active', $list).removeClass('active');
                        itemId.addClass('active');
                    }
                }
                return false;
            };

            if ($list.length) {
                marker.addListener('click', markerListener, false);
            } else {
                marker.addListener('click', listener, false);
                markers.push(marker);
            }

            google.maps.event.addListener(marker, 'mouseover', function () {
                marker.setIcon(iconHover);
            });
            google.maps.event.addListener(marker, 'mouseout', function () {
                marker.setIcon(icon);
            });

            if ($listInspiration.length || $list.length) {
                setTimeout(function () {
                    (0, _jquery2.default)('.map-loading-spinner').hide();
                    (0, _jquery2.default)('.map-wrapper').css('visibility', 'visible');
                }, 2200);
            }
        }

        /**
         * Draw Map
         */
        function drawMap(key, config) {
            _googleMaps2.default.KEY = key;
            _googleMaps2.default.LIBRARIES = ['places', 'geometry'];
            return new _promise2.default(function (resolve) {
                _googleMaps2.default.load(function (google) {
                    var center = config[0] && config[1] ? {
                        lat: parseFloat(config[0]),
                        lng: parseFloat(config[1])
                    } : DEFAULT_MAP_CENTER;

                    var el = document.getElementById('google-map');
                    if (el.dataset.installer === "True") {
                        config[2] = 3;
                    }

                    var zoom = config[2] ? parseFloat(config[2]) : DEFAULT_ZOOM;
                    var options = _extends({}, MAP_OPTIONS, { center: new google.maps.LatLng(center), zoom: zoom });
                    var map = new google.maps.Map(document.getElementById('google-map'), options);
                    resolve({ map: map, google: google });
                });
            });
        }

        /**
         * Init map
         */

        function initMap(key, pins) {
            var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];

            return new _promise2.default(function (resolve) {
                drawMap(key, config).then(function (_ref) {
                    var map = _ref.map,
                        google = _ref.google;

                    pins.map(function (pin) {
                        return drawPin(pin, map, google);
                    });
                    window.SAPATECH.GLOBALGOOGLEMAP_reloadMarkers = function (pinsNew) {

                        for (var i = 0; i < markers.length; i++) {
                            markers[i].setMap(null);

                        }
                        markers.length = 0;
                        pinsNew.map(function (pin) {
                            return drawPin(pin, map, google);
                        });
                    };

                    //Add bounds
                    var bounds = new google.maps.LatLngBounds();
                    for (var i = 0; i < pins.length; i++) {
                        var pt = new google.maps.LatLng(pins[i].location.lat, pins[i].location.lon);
                        bounds.extend(pt);
                    }
                    //Add radius circle
                    var circle = new google.maps.Circle({
                        strokeColor: "#000000",
                        strokeOpacity: 0.5,
                        strokeWeight: 1,
                        fillColor: "#000000",
                        fillOpacity: 0.2,
                        map: map,
                        center: { lat: config[0], lng: config[1] },
                        radius: $('#distanceRange').val() * 1000,
                    });
                    circle.setMap(map);
                    //zoom map to fit circle
                    nb_var = circle.getBounds();
                    var c = circle.getBounds();
                    if (c !== null) {
                        var pt = new google.maps.LatLng(c.getSouthWest().lat(), c.getSouthWest().lng())
                        bounds.extend(pt);
                        var pt = new google.maps.LatLng(c.getNorthEast().lat(), c.getNorthEast().lng())
                        bounds.extend(pt);
                    }
                    map.fitBounds(bounds);
                    initAutocomplete(google, map);
                    resolve(map);
                });
            });
        }

        /***/
    }),
/* 34 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.selectCls = undefined;
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _selectric = __webpack_require__(46);

        var _selectric2 = _interopRequireDefault(_selectric);

        var _contactMap = __webpack_require__(4);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var selectCls = exports.selectCls = '.custom-select';
        var linkSelectCls = '.custom-select--link';

        /**
         * Change location for select with link modifier
         */
        function init() {
            (0, _jquery2.default)(linkSelectCls).on('change', function (event) {
                var href = (0, _jquery2.default)(event.currentTarget).val();
                location.href = '' + href;
            });

            if (_selectric2.default) {
                (0, _jquery2.default)(selectCls).selectric({
                    arrowButtonMarkup: '',
                    disableOnMobile: false,
                    nativeOnMobile: false
                });

                (0, _contactMap.addCustomScroll)('.selectric-scroll', true);

                (0, _jquery2.default)(selectCls).on('selectric-open', function () {
                    (0, _contactMap.updateCustomScroll)('.selectric-scroll', true);
                });

                (0, _jquery2.default)(window).on('resize', function () {
                    (0, _jquery2.default)(selectCls).selectric('close');
                });

                window.selectricRefresh = function () {
                    var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : selectCls;

                    (0, _jquery2.default)(selector).selectric('refresh');
                };
                window.selectricBeforeInit = function () {
                    var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : selectCls;

                    (0, _jquery2.default)(selector).selectric('selectric-before-init');
                };
            }
        }

        /***/
    }),
/* 35 */
/***/ (function (module, exports) {

        // IE 8- don't enum bug keys
        module.exports = (
            'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
        ).split(',');

        /***/
    }),
/* 36 */
/***/ (function (module, exports, __webpack_require__) {

        var global = __webpack_require__(3)
            , core = __webpack_require__(12)
            , hide = __webpack_require__(10)
            , redefine = __webpack_require__(16)
            , ctx = __webpack_require__(20)
            , PROTOTYPE = 'prototype';

        var $export = function (type, name, source) {
            var IS_FORCED = type & $export.F
                , IS_GLOBAL = type & $export.G
                , IS_STATIC = type & $export.S
                , IS_PROTO = type & $export.P
                , IS_BIND = type & $export.B
                , target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]
                , exports = IS_GLOBAL ? core : core[name] || (core[name] = {})
                , expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})
                , key, own, out, exp;
            if (IS_GLOBAL) source = name;
            for (key in source) {
                // contains in native
                own = !IS_FORCED && target && target[key] !== undefined;
                // export native or passed
                out = (own ? target : source)[key];
                // bind timers to global for call from export context
                exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
                // extend global
                if (target) redefine(target, key, out, type & $export.U);
                // export
                if (exports[key] != out) hide(exports, key, exp);
                if (IS_PROTO && expProto[key] != out) expProto[key] = out;
            }
        };
        global.core = core;
        // type bitmap
        $export.F = 1;   // forced
        $export.G = 2;   // global
        $export.S = 4;   // static
        $export.P = 8;   // proto
        $export.B = 16;  // bind
        $export.W = 32;  // wrap
        $export.U = 64;  // safe
        $export.R = 128; // real proto method for `library` 
        module.exports = $export;

        /***/
    }),
/* 37 */
/***/ (function (module, exports) {

        module.exports = function (exec) {
            try {
                return !!exec();
            } catch (e) {
                return true;
            }
        };

        /***/
    }),
/* 38 */
/***/ (function (module, exports, __webpack_require__) {

        module.exports = __webpack_require__(3).document && document.documentElement;

        /***/
    }),
/* 39 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";

        var LIBRARY = __webpack_require__(40)
            , $export = __webpack_require__(36)
            , redefine = __webpack_require__(16)
            , hide = __webpack_require__(10)
            , has = __webpack_require__(14)
            , Iterators = __webpack_require__(15)
            , $iterCreate = __webpack_require__(78)
            , setToStringTag = __webpack_require__(28)
            , getPrototypeOf = __webpack_require__(84)
            , ITERATOR = __webpack_require__(1)('iterator')
            , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
            , FF_ITERATOR = '@@iterator'
            , KEYS = 'keys'
            , VALUES = 'values';

        var returnThis = function () { return this; };

        module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
            $iterCreate(Constructor, NAME, next);
            var getMethod = function (kind) {
                if (!BUGGY && kind in proto) return proto[kind];
                switch (kind) {
                    case KEYS: return function keys() { return new Constructor(this, kind); };
                    case VALUES: return function values() { return new Constructor(this, kind); };
                } return function entries() { return new Constructor(this, kind); };
            };
            var TAG = NAME + ' Iterator'
                , DEF_VALUES = DEFAULT == VALUES
                , VALUES_BUG = false
                , proto = Base.prototype
                , $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
                , $default = $native || getMethod(DEFAULT)
                , $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
                , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
                , methods, key, IteratorPrototype;
            // Fix native
            if ($anyNative) {
                IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
                if (IteratorPrototype !== Object.prototype) {
                    // Set @@toStringTag to native iterators
                    setToStringTag(IteratorPrototype, TAG, true);
                    // fix for some old engines
                    if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);
                }
            }
            // fix Array#{values, @@iterator}.name in V8 / FF
            if (DEF_VALUES && $native && $native.name !== VALUES) {
                VALUES_BUG = true;
                $default = function values() { return $native.call(this); };
            }
            // Define iterator
            if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
                hide(proto, ITERATOR, $default);
            }
            // Plug for library
            Iterators[NAME] = $default;
            Iterators[TAG] = returnThis;
            if (DEFAULT) {
                methods = {
                    values: DEF_VALUES ? $default : getMethod(VALUES),
                    keys: IS_SET ? $default : getMethod(KEYS),
                    entries: $entries
                };
                if (FORCED) for (key in methods) {
                    if (!(key in proto)) redefine(proto, key, methods[key]);
                } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
            }
            return methods;
        };

        /***/
    }),
/* 40 */
/***/ (function (module, exports) {

        module.exports = false;

        /***/
    }),
/* 41 */
/***/ (function (module, exports) {

        module.exports = function (bitmap, value) {
            return {
                enumerable: !(bitmap & 1),
                configurable: !(bitmap & 2),
                writable: !(bitmap & 4),
                value: value
            };
        };

        /***/
    }),
/* 42 */
/***/ (function (module, exports, __webpack_require__) {

        var global = __webpack_require__(3)
            , SHARED = '__core-js_shared__'
            , store = global[SHARED] || (global[SHARED] = {});
        module.exports = function (key) {
            return store[key] || (store[key] = {});
        };

        /***/
    }),
/* 43 */
/***/ (function (module, exports, __webpack_require__) {

        var ctx = __webpack_require__(20)
            , invoke = __webpack_require__(74)
            , html = __webpack_require__(38)
            , cel = __webpack_require__(27)
            , global = __webpack_require__(3)
            , process = global.process
            , setTask = global.setImmediate
            , clearTask = global.clearImmediate
            , MessageChannel = global.MessageChannel
            , counter = 0
            , queue = {}
            , ONREADYSTATECHANGE = 'onreadystatechange'
            , defer, channel, port;
        var run = function () {
            var id = +this;
            if (queue.hasOwnProperty(id)) {
                var fn = queue[id];
                delete queue[id];
                fn();
            }
        };
        var listener = function (event) {
            run.call(event.data);
        };
        // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
        if (!setTask || !clearTask) {
            setTask = function setImmediate(fn) {
                var args = [], i = 1;
                while (arguments.length > i) args.push(arguments[i++]);
                queue[++counter] = function () {
                    invoke(typeof fn == 'function' ? fn : Function(fn), args);
                };
                defer(counter);
                return counter;
            };
            clearTask = function clearImmediate(id) {
                delete queue[id];
            };
            // Node.js 0.8-
            if (__webpack_require__(19)(process) == 'process') {
                defer = function (id) {
                    process.nextTick(ctx(run, id, 1));
                };
                // Browsers with MessageChannel, includes WebWorkers
            } else if (MessageChannel) {
                channel = new MessageChannel;
                port = channel.port2;
                channel.port1.onmessage = listener;
                defer = ctx(port.postMessage, port, 1);
                // Browsers with postMessage, skip WebWorkers
                // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
            } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
                defer = function (id) {
                    global.postMessage(id + '', '*');
                };
                global.addEventListener('message', listener, false);
                // IE8-
            } else if (ONREADYSTATECHANGE in cel('script')) {
                defer = function (id) {
                    html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
                        html.removeChild(this);
                        run.call(id);
                    };
                };
                // Rest old browsers
            } else {
                defer = function (id) {
                    setTimeout(ctx(run, id, 1), 0);
                };
            }
        }
        module.exports = {
            set: setTask,
            clear: clearTask
        };

        /***/
    }),
/* 44 */
/***/ (function (module, exports, __webpack_require__) {

        // 7.1.15 ToLength
        var toInteger = __webpack_require__(30)
            , min = Math.min;
        module.exports = function (it) {
            return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
        };

        /***/
    }),
/* 45 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });

        exports.default = function (element) {
            var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
                lineCount = _ref.lineCount,
                ellipsisCharacter = _ref.ellipsisCharacter;

            // Read the `line-height` of `element`, and use it to compute the height of
            // `element` required to fit the given `lineCount`.
            var lineHeight = parseInt(window.getComputedStyle(element).lineHeight, 10);
            var maximumHeight = lineCount * lineHeight;

            // Exit if text does not overflow the `element`.
            if (element.scrollHeight <= maximumHeight) {
                return;
            }

            truncateByWord(element, maximumHeight);
            truncateByCharacter(element, maximumHeight, ellipsisCharacter || ELLIPSIS);
        };

        var ELLIPSIS = '\u2026';
        var WHITESPACE_REGEX = /(?=\s)/;
        var TRAILING_WHITESPACE_REGEX = /\s+$/;

        // Truncate the text of `element` such that it does not exceed the
        // `maximumHeight`. Return `true` if we need to truncate by character, else
        // return `false`.
        function truncateByWord(element, maximumHeight) {
            var innerHTML = element.innerHTML;

            // Split the text of `element` by whitespace.
            var chunks = innerHTML.split(WHITESPACE_REGEX);

            // The text does not contain whitespace; we need to attempt to truncate
            // by character.
            if (chunks.length === 1) {
                return true;
            }

            // Loop over the chunks, and try to fit more chunks into the `element`.
            var i = -1;
            var length = chunks.length;
            var newInnerHTML = '';
            while (++i < length) {
                newInnerHTML += chunks[i];
                element.innerHTML = newInnerHTML;

                // If the new height now exceeds the `maximumHeight` (where it did not
                // in the previous iteration), we know that we are at most one line
                // over the optimal text length.
                if (element.offsetHeight > maximumHeight) {
                    return true;
                }
            }

            return false;
        }

        // Append `ellipsisCharacter` to `element`, trimming off trailing characters
        // in `element` such that `element` will not exceed the `maximumHeight`.
        function truncateByCharacter(element, maximumHeight, ellipsisCharacter) {
            var innerHTML = element.innerHTML;
            var length = innerHTML.length;

            // In each iteration, we trim off one trailing character . Also trim
            // off any trailing punctuation before appending the `ellipsisCharacter`.
            while (length > 0) {
                element.innerHTML = innerHTML.substring(0, length).replace(TRAILING_WHITESPACE_REGEX, '') + ellipsisCharacter;
                if (element.offsetHeight <= maximumHeight) {
                    return;
                }
                length--;
            }
        }

        /***/
    }),
/* 46 */
/***/ (function (module, exports, __webpack_require__) {

        var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 *         ,/
 *       ,'/
 *     ,' /
 *   ,'  /_____,
 * .'____    ,'
 *      /  ,'
 *     / ,'
 *    /,'
 *   /'
 *
 * Selectric ϟ v1.11.1 (Jan 10 2017) - http://lcdsantos.github.io/jQuery-Selectric/
 *
 * Copyright (c) 2017 Leonardo Santos; MIT License
 *
 */

        (function (factory) {
            /* global define */
            /* istanbul ignore next */
            if (true) {
                !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
                    __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
                        (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
                    __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
            } else if (typeof module === 'object' && module.exports) {
                // Node/CommonJS
                module.exports = function (root, jQuery) {
                    if (jQuery === undefined) {
                        if (typeof window !== 'undefined') {
                            jQuery = require('jquery');
                        } else {
                            jQuery = require('jquery')(root);
                        }
                    }
                    factory(jQuery);
                    return jQuery;
                };
            } else {
                // Browser globals
                factory(jQuery);
            }
        }(function ($) {
            'use strict';

            var $doc = $(document);
            var $win = $(window);

            var pluginName = 'selectric';
            var classList = 'Input Items Open Disabled TempShow HideSelect Wrapper Focus Hover Responsive Above Scroll Group GroupLabel';
            var eventNamespaceSuffix = '.sl';

            var chars = ['a', 'e', 'i', 'o', 'u', 'n', 'c', 'y'];
            var diacritics = [
                /[\xE0-\xE5]/g, // a
                /[\xE8-\xEB]/g, // e
                /[\xEC-\xEF]/g, // i
                /[\xF2-\xF6]/g, // o
                /[\xF9-\xFC]/g, // u
                /[\xF1]/g,      // n
                /[\xE7]/g,      // c
                /[\xFD-\xFF]/g  // y
            ];

            /**
             * Create an instance of Selectric
             *
             * @constructor
             * @param {Node} element - The &lt;select&gt; element
             * @param {object}  opts - Options
             */
            var Selectric = function (element, opts) {
                var _this = this;

                _this.element = element;
                _this.$element = $(element);

                _this.state = {
                    multiple: !!_this.$element.attr('multiple'),
                    enabled: false,
                    opened: false,
                    currValue: -1,
                    selectedIdx: -1,
                    highlightedIdx: -1
                };

                _this.eventTriggers = {
                    open: _this.open,
                    close: _this.close,
                    destroy: _this.destroy,
                    refresh: _this.refresh,
                    init: _this.init
                };

                _this.init(opts);
            };

            Selectric.prototype = {
                utils: {
                    /**
                     * Detect mobile browser
                     *
                     * @return {boolean}
                     */
                    isMobile: function () {
                        return /android|ip(hone|od|ad)/i.test(navigator.userAgent);
                    },

                    /**
                     * Escape especial characters in string (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions)
                     *
                     * @param  {string} str - The string to be escaped
                     * @return {string}       The string with the special characters escaped
                     */
                    escapeRegExp: function (str) {
                        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
                    },

                    /**
                     * Replace diacritics
                     *
                     * @param  {string} str - The string to replace the diacritics
                     * @return {string}       The string with diacritics replaced with ascii characters
                     */
                    replaceDiacritics: function (str) {
                        var k = diacritics.length;

                        while (k--) {
                            str = str.toLowerCase().replace(diacritics[k], chars[k]);
                        }

                        return str;
                    },

                    /**
                     * Format string
                     * https://gist.github.com/atesgoral/984375
                     *
                     * @param  {string} f - String to be formated
                     * @return {string}     String formated
                     */
                    format: function (f) {
                        var a = arguments; // store outer arguments
                        return ('' + f) // force format specifier to String
                            .replace( // replace tokens in format specifier
                                /\{(?:(\d+)|(\w+))\}/g, // match {token} references
                                function (
                                    s, // the matched string (ignored)
                                    i, // an argument index
                                    p // a property name
                                ) {
                                    return p && a[1] // if property name and first argument exist
                                        ? a[1][p] // return property from first argument
                                        : a[i]; // assume argument index and return i-th argument
                                });
                    },

                    /**
                     * Get the next enabled item in the options list.
                     *
                     * @param  {object} selectItems - The options object.
                     * @param  {number}    selected - Index of the currently selected option.
                     * @return {object}               The next enabled item.
                     */
                    nextEnabledItem: function (selectItems, selected) {
                        while (selectItems[selected = (selected + 1) % selectItems.length].disabled) {
                            // empty
                        }
                        return selected;
                    },

                    /**
                     * Get the previous enabled item in the options list.
                     *
                     * @param  {object} selectItems - The options object.
                     * @param  {number}    selected - Index of the currently selected option.
                     * @return {object}               The previous enabled item.
                     */
                    previousEnabledItem: function (selectItems, selected) {
                        while (selectItems[selected = (selected > 0 ? selected : selectItems.length) - 1].disabled) {
                            // empty
                        }
                        return selected;
                    },

                    /**
                     * Transform camelCase string to dash-case.
                     *
                     * @param  {string} str - The camelCased string.
                     * @return {string}       The string transformed to dash-case.
                     */
                    toDash: function (str) {
                        return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
                    },

                    /**
                     * Calls the events registered with function name.
                     *
                     * @param {string}    fn - The name of the function.
                     * @param {number} scope - Scope that should be set on the function.
                     */
                    triggerCallback: function (fn, scope) {
                        var elm = scope.element;
                        var func = scope.options['on' + fn];
                        var args = [elm].concat([].slice.call(arguments).slice(1));

                        if ($.isFunction(func)) {
                            func.apply(elm, args);
                        }

                        $(elm).trigger(pluginName + '-' + this.toDash(fn), args);
                    },

                    /**
                     * Transform array list to concatenated string and remove empty values
                     * @param  {array} arr - Class list
                     * @return {string}      Concatenated string
                     */
                    arrayToClassname: function (arr) {
                        var newArr = $.grep(arr, function (item) {
                            return !!item;
                        });

                        return $.trim(newArr.join(' '));
                    }
                },

                /** Initializes */
                init: function (opts) {
                    var _this = this;

                    // Set options
                    _this.options = $.extend(true, {}, $.fn[pluginName].defaults, _this.options, opts);

                    _this.utils.triggerCallback('BeforeInit', _this);

                    // Preserve data
                    _this.destroy(true);

                    // Disable on mobile browsers
                    if (_this.options.disableOnMobile && _this.utils.isMobile()) {
                        _this.disableOnMobile = true;
                        return;
                    }

                    // Get classes
                    _this.classes = _this.getClassNames();

                    // Create elements
                    var input = $('<input/>', { 'class': _this.classes.input, 'readonly': _this.utils.isMobile() });
                    var items = $('<div/>', { 'class': _this.classes.items, 'tabindex': -1 });
                    var itemsScroll = $('<div/>', { 'class': _this.classes.scroll });
                    var wrapper = $('<div/>', { 'class': _this.classes.prefix, 'html': _this.options.arrowButtonMarkup });
                    var label = $('<span/>', { 'class': 'label' });
                    var outerWrapper = _this.$element.wrap('<div/>').parent().append(wrapper.prepend(label), items, input);
                    var hideSelectWrapper = $('<div/>', { 'class': _this.classes.hideselect });

                    _this.elements = {
                        input: input,
                        items: items,
                        itemsScroll: itemsScroll,
                        wrapper: wrapper,
                        label: label,
                        outerWrapper: outerWrapper
                    };

                    if (_this.options.nativeOnMobile && _this.utils.isMobile()) {
                        _this.elements.input = undefined;
                        hideSelectWrapper.addClass(_this.classes.prefix + '-is-native');

                        _this.$element.on('change', function () {
                            _this.refresh();
                        });
                    }

                    _this.$element
                        .on(_this.eventTriggers)
                        .wrap(hideSelectWrapper);

                    _this.originalTabindex = _this.$element.prop('tabindex');
                    _this.$element.prop('tabindex', -1);

                    _this.populate();
                    _this.activate();

                    _this.utils.triggerCallback('Init', _this);
                },

                /** Activates the plugin */
                activate: function () {
                    var _this = this;
                    var hiddenChildren = _this.elements.items.closest(':visible').children(':hidden').addClass(_this.classes.tempshow);
                    var originalWidth = _this.$element.width();

                    hiddenChildren.removeClass(_this.classes.tempshow);

                    _this.utils.triggerCallback('BeforeActivate', _this);

                    _this.elements.outerWrapper.prop('class',
                        _this.utils.arrayToClassname([
                            _this.classes.wrapper,
                            _this.$element.prop('class').replace(/\S+/g, _this.classes.prefix + '-$&'),
                            _this.options.responsive ? _this.classes.responsive : ''
                        ])
                    );

                    if (_this.options.inheritOriginalWidth && originalWidth > 0) {
                        _this.elements.outerWrapper.width(originalWidth);
                    }

                    _this.unbindEvents();

                    if (!_this.$element.prop('disabled')) {
                        _this.state.enabled = true;

                        // Not disabled, so... Removing disabled class
                        _this.elements.outerWrapper.removeClass(_this.classes.disabled);

                        // Remove styles from items box
                        // Fix incorrect height when refreshed is triggered with fewer options
                        _this.$li = _this.elements.items.removeAttr('style').find('li');

                        _this.bindEvents();
                    } else {
                        _this.elements.outerWrapper.addClass(_this.classes.disabled);

                        if (_this.elements.input) {
                            _this.elements.input.prop('disabled', true);
                        }
                    }

                    _this.utils.triggerCallback('Activate', _this);
                },

                /**
                 * Generate classNames for elements
                 *
                 * @return {object} Classes object
                 */
                getClassNames: function () {
                    var _this = this;
                    var customClass = _this.options.customClass;
                    var classesObj = {};

                    $.each(classList.split(' '), function (i, currClass) {
                        var c = customClass.prefix + currClass;
                        classesObj[currClass.toLowerCase()] = customClass.camelCase ? c : _this.utils.toDash(c);
                    });

                    classesObj.prefix = customClass.prefix;

                    return classesObj;
                },

                /** Set the label text */
                setLabel: function () {
                    var _this = this;
                    var labelBuilder = _this.options.labelBuilder;

                    if (_this.state.multiple) {
                        // Make sure currentValues is an array
                        var currentValues = $.isArray(_this.state.currValue) ? _this.state.currValue : [_this.state.currValue];
                        // I'm not happy with this, but currentValues can be an empty
                        // array and we need to fallback to the default option.
                        currentValues = currentValues.length === 0 ? [0] : currentValues;

                        var labelMarkup = $.map(currentValues, function (value) {
                            return $.grep(_this.lookupItems, function (item) {
                                return item.index === value;
                            })[0]; // we don't want nested arrays here
                        });

                        labelMarkup = $.grep(labelMarkup, function (item) {
                            // Hide default (please choose) if more then one element were selected.
                            // If no option value were given value is set to option text by default
                            if (labelMarkup.length > 1 || labelMarkup.length === 0) {
                                return $.trim(item.value) !== '';
                            }
                            return item;
                        });

                        labelMarkup = $.map(labelMarkup, function (item) {
                            return $.isFunction(labelBuilder)
                                ? labelBuilder(item)
                                : _this.utils.format(labelBuilder, item);
                        });

                        // Limit the amount of selected values shown in label
                        if (_this.options.multiple.maxLabelEntries) {
                            if (labelMarkup.length >= _this.options.multiple.maxLabelEntries + 1) {
                                labelMarkup = labelMarkup.slice(0, _this.options.multiple.maxLabelEntries);
                                labelMarkup.push(
                                    $.isFunction(labelBuilder)
                                        ? labelBuilder({ text: '...' })
                                        : _this.utils.format(labelBuilder, { text: '...' }));
                            } else {
                                labelMarkup.slice(labelMarkup.length - 1);
                            }
                        }
                        _this.elements.label.html(labelMarkup.join(_this.options.multiple.separator));

                    } else {
                        var currItem = _this.lookupItems[_this.state.currValue];

                        _this.elements.label.html(
                            $.isFunction(labelBuilder)
                                ? labelBuilder(currItem)
                                : _this.utils.format(labelBuilder, currItem)
                        );
                    }
                },

                /** Get and save the available options */
                populate: function () {
                    var _this = this;
                    var $options = _this.$element.children();
                    var $justOptions = _this.$element.find('option');
                    var $selected = $justOptions.filter(':selected');
                    var selectedIndex = $justOptions.index($selected);
                    var currIndex = 0;
                    var emptyValue = (_this.state.multiple ? [] : 0);

                    if ($selected.length > 1 && _this.state.multiple) {
                        selectedIndex = [];
                        $selected.each(function () {
                            selectedIndex.push($(this).index());
                        });
                    }

                    _this.state.currValue = (~selectedIndex ? selectedIndex : emptyValue);
                    _this.state.selectedIdx = _this.state.currValue;
                    _this.state.highlightedIdx = _this.state.currValue;
                    _this.items = [];
                    _this.lookupItems = [];

                    if ($options.length) {
                        // Build options markup
                        $options.each(function (i) {
                            var $elm = $(this);

                            if ($elm.is('optgroup')) {

                                var optionsGroup = {
                                    element: $elm,
                                    label: $elm.prop('label'),
                                    groupDisabled: $elm.prop('disabled'),
                                    items: []
                                };

                                $elm.children().each(function (i) {
                                    var $elm = $(this);

                                    optionsGroup.items[i] = _this.getItemData(currIndex, $elm, optionsGroup.groupDisabled || $elm.prop('disabled'));

                                    _this.lookupItems[currIndex] = optionsGroup.items[i];

                                    currIndex++;
                                });

                                _this.items[i] = optionsGroup;

                            } else {

                                _this.items[i] = _this.getItemData(currIndex, $elm, $elm.prop('disabled'));

                                _this.lookupItems[currIndex] = _this.items[i];

                                currIndex++;

                            }
                        });

                        _this.setLabel();
                        _this.elements.items.append(_this.elements.itemsScroll.html(_this.getItemsMarkup(_this.items)));
                    }
                },

                /**
                 * Generate items object data
                 * @param  {integer} index      - Current item index
                 * @param  {node}    $elm       - Current element node
                 * @param  {boolean} isDisabled - Current element disabled state
                 * @return {object}               Item object
                 */
                getItemData: function (index, $elm, isDisabled) {
                    var _this = this;

                    return {
                        index: index,
                        element: $elm,
                        value: $elm.val(),
                        className: $elm.prop('class'),
                        text: $elm.html(),
                        slug: $.trim(_this.utils.replaceDiacritics($elm.html())),
                        selected: $elm.prop('selected'),
                        disabled: isDisabled
                    };
                },

                /**
                 * Generate options markup
                 *
                 * @param  {object} items - Object containing all available options
                 * @return {string}         HTML for the options box
                 */
                getItemsMarkup: function (items) {
                    var _this = this;
                    var markup = '<ul>';

                    if ($.isFunction(_this.options.listBuilder) && _this.options.listBuilder) {
                        items = _this.options.listBuilder(items);
                    }

                    $.each(items, function (i, elm) {
                        if (elm.label !== undefined) {

                            markup += _this.utils.format('<ul class="{1}"><li class="{2}">{3}</li>',
                                _this.utils.arrayToClassname([
                                    _this.classes.group,
                                    elm.groupDisabled ? 'disabled' : '',
                                    elm.element.prop('class')
                                ]),
                                _this.classes.grouplabel,
                                elm.element.prop('label')
                            );

                            $.each(elm.items, function (i, elm) {
                                markup += _this.getItemMarkup(elm.index, elm);
                            });

                            markup += '</ul>';

                        } else {

                            markup += _this.getItemMarkup(elm.index, elm);

                        }
                    });

                    return markup + '</ul>';
                },

                /**
                 * Generate every option markup
                 *
                 * @param  {number} index    - Index of current item
                 * @param  {object} itemData - Current item
                 * @return {string}            HTML for the option
                 */
                getItemMarkup: function (index, itemData) {
                    var _this = this;
                    var itemBuilder = _this.options.optionsItemBuilder;
                    // limit access to item data to provide a simple interface
                    // to most relevant options.
                    var filteredItemData = {
                        value: itemData.value,
                        text: itemData.text,
                        slug: itemData.slug,
                        index: itemData.index
                    };

                    return _this.utils.format('<li data-index="{1}" class="{2}">{3}</li>',
                        index,
                        _this.utils.arrayToClassname([
                            itemData.className,
                            index === _this.items.length - 1 ? 'last' : '',
                            itemData.disabled ? 'disabled' : '',
                            itemData.selected ? 'selected' : ''
                        ]),
                        $.isFunction(itemBuilder)
                            ? _this.utils.format(itemBuilder(itemData), itemData)
                            : _this.utils.format(itemBuilder, filteredItemData)
                    );
                },

                /** Remove events on the elements */
                unbindEvents: function () {
                    var _this = this;

                    _this.elements.wrapper
                        .add(_this.$element)
                        .add(_this.elements.outerWrapper)
                        .add(_this.elements.input)
                        .off(eventNamespaceSuffix);
                },

                /** Bind events on the elements */
                bindEvents: function () {
                    var _this = this;

                    _this.elements.outerWrapper.on('mouseenter' + eventNamespaceSuffix + ' mouseleave' + eventNamespaceSuffix, function (e) {
                        $(this).toggleClass(_this.classes.hover, e.type === 'mouseenter');

                        // Delay close effect when openOnHover is true
                        if (_this.options.openOnHover) {
                            clearTimeout(_this.closeTimer);

                            if (e.type === 'mouseleave') {
                                _this.closeTimer = setTimeout($.proxy(_this.close, _this), _this.options.hoverIntentTimeout);
                            } else {
                                _this.open();
                            }
                        }
                    });

                    // Toggle open/close
                    _this.elements.wrapper.on('click' + eventNamespaceSuffix, function (e) {
                        _this.state.opened ? _this.close() : _this.open(e);
                    });

                    // Translate original element focus event to dummy input.
                    // Disabled on mobile devices because the default option list isn't
                    // shown due the fact that hidden input gets focused
                    if (!(_this.options.nativeOnMobile && _this.utils.isMobile())) {
                        _this.$element.on('focus' + eventNamespaceSuffix, function () {
                            _this.elements.input.focus();
                        });

                        _this.elements.input
                            .prop({ tabindex: _this.originalTabindex, disabled: false })
                            .on('keydown' + eventNamespaceSuffix, $.proxy(_this.handleKeys, _this))
                            .on('focusin' + eventNamespaceSuffix, function (e) {
                                _this.elements.outerWrapper.addClass(_this.classes.focus);

                                // Prevent the flicker when focusing out and back again in the browser window
                                _this.elements.input.one('blur', function () {
                                    _this.elements.input.blur();
                                });

                                if (_this.options.openOnFocus && !_this.state.opened) {
                                    _this.open(e);
                                }
                            })
                            .on('focusout' + eventNamespaceSuffix, function () {
                                _this.elements.outerWrapper.removeClass(_this.classes.focus);
                            })
                            .on('input propertychange', function () {
                                var val = _this.elements.input.val();
                                var searchRegExp = new RegExp('^' + _this.utils.escapeRegExp(val), 'i');

                                // Clear search
                                clearTimeout(_this.resetStr);
                                _this.resetStr = setTimeout(function () {
                                    _this.elements.input.val('');
                                }, _this.options.keySearchTimeout);

                                if (val.length) {
                                    // Search in select options
                                    $.each(_this.items, function (i, elm) {
                                        if (!elm.disabled && searchRegExp.test(elm.text) || searchRegExp.test(elm.slug)) {
                                            _this.highlight(i);
                                            return;
                                        }
                                    });
                                }
                            });
                    }

                    _this.$li.on({
                        // Prevent <input> blur on Chrome
                        mousedown: function (e) {
                            e.preventDefault();
                            e.stopPropagation();
                        },
                        click: function () {
                            _this.select($(this).data('index'));

                            // Chrome doesn't close options box if select is wrapped with a label
                            // We need to 'return false' to avoid that
                            return false;
                        }
                    });
                },

                /**
                 * Behavior when keyboard keys is pressed
                 *
                 * @param {object} e - Event object
                 */
                handleKeys: function (e) {
                    var _this = this;
                    var key = e.which;
                    var keys = _this.options.keys;

                    var isPrevKey = $.inArray(key, keys.previous) > -1;
                    var isNextKey = $.inArray(key, keys.next) > -1;
                    var isSelectKey = $.inArray(key, keys.select) > -1;
                    var isOpenKey = $.inArray(key, keys.open) > -1;
                    var idx = _this.state.highlightedIdx;
                    var isFirstOrLastItem = (isPrevKey && idx === 0) || (isNextKey && (idx + 1) === _this.items.length);
                    var goToItem = 0;

                    // Enter / Space
                    if (key === 13 || key === 32) {
                        e.preventDefault();
                    }

                    // If it's a directional key
                    if (isPrevKey || isNextKey) {
                        if (!_this.options.allowWrap && isFirstOrLastItem) {
                            return;
                        }

                        if (isPrevKey) {
                            goToItem = _this.utils.previousEnabledItem(_this.lookupItems, idx);
                        }

                        if (isNextKey) {
                            goToItem = _this.utils.nextEnabledItem(_this.lookupItems, idx);
                        }

                        _this.highlight(goToItem);
                    }

                    // Tab / Enter / ESC
                    if (isSelectKey && _this.state.opened) {
                        _this.select(idx);

                        if (!_this.state.multiple || !_this.options.multiple.keepMenuOpen) {
                            _this.close();
                        }

                        return;
                    }

                    // Space / Enter / Left / Up / Right / Down
                    if (isOpenKey && !_this.state.opened) {
                        _this.open();
                    }
                },

                /** Update the items object */
                refresh: function () {
                    var _this = this;

                    _this.populate();
                    _this.activate();
                    _this.utils.triggerCallback('Refresh', _this);
                },

                /** Set options box width/height */
                setOptionsDimensions: function () {
                    var _this = this;

                    // Calculate options box height
                    // Set a temporary class on the hidden parent of the element
                    var hiddenChildren = _this.elements.items.closest(':visible').children(':hidden').addClass(_this.classes.tempshow);
                    var maxHeight = _this.options.maxHeight;
                    var itemsWidth = _this.elements.items.outerWidth();
                    var wrapperWidth = _this.elements.wrapper.outerWidth() - (itemsWidth - _this.elements.items.width());

                    // Set the dimensions, minimum is wrapper width, expand for long items if option is true
                    if (!_this.options.expandToItemText || wrapperWidth > itemsWidth) {
                        _this.finalWidth = wrapperWidth;
                    } else {
                        // Make sure the scrollbar width is included
                        _this.elements.items.css('overflow', 'scroll');

                        // Set a really long width for _this.elements.outerWrapper
                        _this.elements.outerWrapper.width(9e4);
                        _this.finalWidth = _this.elements.items.width();
                        // Set scroll bar to auto
                        _this.elements.items.css('overflow', '');
                        _this.elements.outerWrapper.width('');
                    }

                    _this.elements.items.width(_this.finalWidth).height() > maxHeight && _this.elements.items.height(maxHeight);

                    // Remove the temporary class
                    hiddenChildren.removeClass(_this.classes.tempshow);
                },

                /** Detect if the options box is inside the window */
                isInViewport: function () {
                    var _this = this;
                    var scrollTop = $win.scrollTop();
                    var winHeight = $win.height();
                    var uiPosX = _this.elements.outerWrapper.offset().top;
                    var uiHeight = _this.elements.outerWrapper.outerHeight();

                    var fitsDown = (uiPosX + uiHeight + _this.itemsHeight) <= (scrollTop + winHeight);
                    var fitsAbove = (uiPosX - _this.itemsHeight) > scrollTop;

                    // If it does not fit below, only render it
                    // above it fit's there.
                    // It's acceptable that the user needs to
                    // scroll the viewport to see the cut off UI
                    var renderAbove = !fitsDown && fitsAbove;

                    _this.elements.outerWrapper.toggleClass(_this.classes.above, renderAbove);
                },

                /**
                 * Detect if currently selected option is visible and scroll the options box to show it
                 *
                 * @param {Number|Array} index - Index of the selected items
                 */
                detectItemVisibility: function (index) {
                    var _this = this;
                    var $filteredLi = _this.$li.filter('[data-index]');

                    if (_this.state.multiple) {
                        // If index is an array, we can assume a multiple select and we
                        // want to scroll to the uppermost selected item!
                        // Math.min.apply(Math, index) returns the lowest entry in an Array.
                        index = ($.isArray(index) && index.length === 0) ? 0 : index;
                        index = $.isArray(index) ? Math.min.apply(Math, index) : index;
                    }

                    var liHeight = $filteredLi.eq(index).outerHeight();
                    var liTop = $filteredLi[index].offsetTop;
                    var itemsScrollTop = _this.elements.itemsScroll.scrollTop();
                    var scrollT = liTop + liHeight * 2;

                    _this.elements.itemsScroll.scrollTop(
                        scrollT > itemsScrollTop + _this.itemsHeight ? scrollT - _this.itemsHeight :
                            liTop - liHeight < itemsScrollTop ? liTop - liHeight :
                                itemsScrollTop
                    );
                },

                /**
                 * Open the select options box
                 *
                 * @param {Event} e - Event
                 */
                open: function (e) {
                    var _this = this;

                    if (_this.options.nativeOnMobile && _this.utils.isMobile()) {
                        return false;
                    }

                    _this.utils.triggerCallback('BeforeOpen', _this);

                    if (e) {
                        e.preventDefault();
                        if (_this.options.stopPropagation) {
                            e.stopPropagation();
                        }
                    }

                    if (_this.state.enabled) {
                        _this.setOptionsDimensions();

                        // Find any other opened instances of select and close it
                        $('.' + _this.classes.hideselect, '.' + _this.classes.open).children()[pluginName]('close');

                        _this.state.opened = true;
                        _this.itemsHeight = _this.elements.items.outerHeight();
                        _this.itemsInnerHeight = _this.elements.items.height();

                        // Toggle options box visibility
                        _this.elements.outerWrapper.addClass(_this.classes.open);

                        // Give dummy input focus
                        _this.elements.input.val('');
                        if (e && e.type !== 'focusin') {
                            _this.elements.input.focus();
                        }

                        // Delayed binds events on Document to make label clicks work
                        setTimeout(function () {
                            $doc
                                .on('click' + eventNamespaceSuffix, $.proxy(_this.close, _this))
                                .on('scroll' + eventNamespaceSuffix, $.proxy(_this.isInViewport, _this));
                        }, 1);

                        _this.isInViewport();

                        // Prevent window scroll when using mouse wheel inside items box
                        if (_this.options.preventWindowScroll) {
                            /* istanbul ignore next */
                            $doc.on('mousewheel' + eventNamespaceSuffix + ' DOMMouseScroll' + eventNamespaceSuffix, '.' + _this.classes.scroll, function (e) {
                                var orgEvent = e.originalEvent;
                                var scrollTop = $(this).scrollTop();
                                var deltaY = 0;

                                if ('detail' in orgEvent) { deltaY = orgEvent.detail * -1; }
                                if ('wheelDelta' in orgEvent) { deltaY = orgEvent.wheelDelta; }
                                if ('wheelDeltaY' in orgEvent) { deltaY = orgEvent.wheelDeltaY; }
                                if ('deltaY' in orgEvent) { deltaY = orgEvent.deltaY * -1; }

                                if (scrollTop === (this.scrollHeight - _this.itemsInnerHeight) && deltaY < 0 || scrollTop === 0 && deltaY > 0) {
                                    e.preventDefault();
                                }
                            });
                        }

                        _this.detectItemVisibility(_this.state.selectedIdx);

                        _this.highlight(_this.state.multiple ? -1 : _this.state.selectedIdx);

                        _this.utils.triggerCallback('Open', _this);
                    }
                },

                /** Close the select options box */
                close: function () {
                    var _this = this;

                    _this.utils.triggerCallback('BeforeClose', _this);

                    // Remove custom events on document
                    $doc.off(eventNamespaceSuffix);

                    // Remove visible class to hide options box
                    _this.elements.outerWrapper.removeClass(_this.classes.open);

                    _this.state.opened = false;

                    _this.utils.triggerCallback('Close', _this);
                },

                /** Select current option and change the label */
                change: function () {
                    var _this = this;

                    _this.utils.triggerCallback('BeforeChange', _this);

                    if (_this.state.multiple) {
                        // Reset old selected
                        $.each(_this.lookupItems, function (idx) {
                            _this.lookupItems[idx].selected = false;
                            _this.$element.find('option').prop('selected', false);
                        });

                        // Set new selected
                        $.each(_this.state.selectedIdx, function (idx, value) {
                            _this.lookupItems[value].selected = true;
                            _this.$element.find('option').eq(value).prop('selected', true);
                        });

                        _this.state.currValue = _this.state.selectedIdx;

                        _this.setLabel();

                        _this.utils.triggerCallback('Change', _this);
                    } else if (_this.state.currValue !== _this.state.selectedIdx) {
                        // Apply changed value to original select
                        _this.$element
                            .prop('selectedIndex', _this.state.currValue = _this.state.selectedIdx)
                            .data('value', _this.lookupItems[_this.state.selectedIdx].text);

                        // Change label text
                        _this.setLabel();

                        _this.utils.triggerCallback('Change', _this);
                    }
                },

                /**
                 * Highlight option
                 * @param {number} index - Index of the options that will be highlighted
                 */
                highlight: function (index) {
                    var _this = this;
                    var $filteredLi = _this.$li.filter('[data-index]').removeClass('highlighted');

                    _this.utils.triggerCallback('BeforeHighlight', _this);

                    // Parameter index is required and should not be a disabled item
                    if (index === undefined || index === -1 || _this.lookupItems[index].disabled) {
                        return;
                    }

                    $filteredLi
                        .eq(_this.state.highlightedIdx = index)
                        .addClass('highlighted');

                    _this.detectItemVisibility(index);

                    _this.utils.triggerCallback('Highlight', _this);
                },

                /**
                 * Select option
                 *
                 * @param {number} index - Index of the option that will be selected
                 */
                select: function (index) {
                    var _this = this;
                    var $filteredLi = _this.$li.filter('[data-index]');

                    _this.utils.triggerCallback('BeforeSelect', _this, index);

                    // Parameter index is required and should not be a disabled item
                    if (index === undefined || index === -1 || _this.lookupItems[index].disabled) {
                        return;
                    }

                    if (_this.state.multiple) {
                        // Make sure selectedIdx is an array
                        _this.state.selectedIdx = $.isArray(_this.state.selectedIdx) ? _this.state.selectedIdx : [_this.state.selectedIdx];

                        var hasSelectedIndex = $.inArray(index, _this.state.selectedIdx);
                        if (hasSelectedIndex !== -1) {
                            _this.state.selectedIdx.splice(hasSelectedIndex, 1);
                        } else {
                            _this.state.selectedIdx.push(index);
                        }

                        $filteredLi
                            .removeClass('selected')
                            .filter(function (index) {
                                return $.inArray(index, _this.state.selectedIdx) !== -1;
                            })
                            .addClass('selected');
                    } else {
                        $filteredLi
                            .removeClass('selected')
                            .eq(_this.state.selectedIdx = index)
                            .addClass('selected');
                    }

                    if (!_this.state.multiple || !_this.options.multiple.keepMenuOpen) {
                        _this.close();
                    }

                    _this.change();

                    _this.utils.triggerCallback('Select', _this, index);
                },

                /**
                 * Unbind and remove
                 *
                 * @param {boolean} preserveData - Check if the data on the element should be removed too
                 */
                destroy: function (preserveData) {
                    var _this = this;

                    if (_this.state && _this.state.enabled) {
                        _this.elements.items.add(_this.elements.wrapper).add(_this.elements.input).remove();

                        if (!preserveData) {
                            _this.$element.removeData(pluginName).removeData('value');
                        }

                        _this.$element.prop('tabindex', _this.originalTabindex).off(eventNamespaceSuffix).off(_this.eventTriggers).unwrap().unwrap();

                        _this.state.enabled = false;
                    }
                }
            };

            // A really lightweight plugin wrapper around the constructor,
            // preventing against multiple instantiations
            $.fn[pluginName] = function (args) {
                return this.each(function () {
                    var data = $.data(this, pluginName);

                    if (data && !data.disableOnMobile) {
                        (typeof args === 'string' && data[args]) ? data[args]() : data.init(args);
                    } else {
                        $.data(this, pluginName, new Selectric(this, args));
                    }
                });
            };

            /**
             * Default plugin options
             *
             * @type {object}
             */
            $.fn[pluginName].defaults = {
                onChange: function (elm) { $(elm).change(); },
                maxHeight: 300,
                keySearchTimeout: 500,
                arrowButtonMarkup: '<b class="button">&#x25be;</b>',
                disableOnMobile: false,
                nativeOnMobile: true,
                openOnFocus: true,
                openOnHover: false,
                hoverIntentTimeout: 500,
                expandToItemText: false,
                responsive: false,
                preventWindowScroll: true,
                inheritOriginalWidth: false,
                allowWrap: true,
                stopPropagation: true,
                optionsItemBuilder: '{text}', // function(itemData, element, index)
                labelBuilder: '{text}', // function(currItem)
                listBuilder: false,    // function(items)
                keys: {
                    previous: [37, 38],                 // Left / Up
                    next: [39, 40],                 // Right / Down
                    select: [9, 13, 27],              // Tab / Enter / Escape
                    open: [13, 32, 37, 38, 39, 40], // Enter / Space / Left / Up / Right / Down
                    close: [9, 27]                   // Tab / Escape
                },
                customClass: {
                    prefix: pluginName,
                    camelCase: false
                },
                multiple: {
                    separator: ', ',
                    keepMenuOpen: true,
                    maxLabelEntries: false
                }
            };
        }));


        /***/
    }),
/* 47 */
/***/ (function (module, exports, __webpack_require__) {

        var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*
     _ _      _       _
 ___| (_) ___| | __  (_)___
/ __| | |/ __| |/ /  | / __|
\__ \ | | (__|   < _ | \__ \
|___/_|_|\___|_|\_(_)/ |___/
                   |__/

 Version: 1.6.0
  Author: Ken Wheeler
 Website: http://kenwheeler.github.io
    Docs: http://kenwheeler.github.io/slick
    Repo: http://github.com/kenwheeler/slick
  Issues: http://github.com/kenwheeler/slick/issues

 */
        /* global window, document, define, jQuery, setInterval, clearInterval */
        (function (factory) {
            'use strict';
            if (true) {
                !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
                    __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
                        (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
                    __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
            } else if (typeof exports !== 'undefined') {
                module.exports = factory(require('jquery'));
            } else {
                factory(jQuery);
            }

        }(function ($) {
            'use strict';
            var Slick = window.Slick || {};

            Slick = (function () {

                var instanceUid = 0;

                function Slick(element, settings) {

                    var _ = this, dataSettings;

                    _.defaults = {
                        accessibility: true,
                        adaptiveHeight: false,
                        appendArrows: $(element),
                        appendDots: $(element),
                        arrows: true,
                        asNavFor: null,
                        //prevArrow: '<button type="button" data-role="none" class="slick-prev" aria-label="Previous" tabindex="0" role="button">Previous</button>',
                        //nextArrow: '<button type="button" data-role="none" class="slick-next" aria-label="Next" tabindex="0" role="button">Next</button>',
                        autoplay: false,
                        autoplaySpeed: 3000,
                        centerMode: false,
                        centerPadding: '50px',
                        cssEase: 'ease',
                        customPaging: function (slider, i) {
                            return $('<button type="button" data-role="none" role="button" tabindex="0" />').text(i + 1);
                        },
                        dots: false,
                        dotsClass: 'slick-dots',
                        draggable: true,
                        easing: 'linear',
                        edgeFriction: 0.35,
                        fade: false,
                        focusOnSelect: false,
                        infinite: true,
                        initialSlide: 0,
                        lazyLoad: 'ondemand',
                        mobileFirst: false,
                        pauseOnHover: true,
                        pauseOnFocus: true,
                        pauseOnDotsHover: false,
                        respondTo: 'window',
                        responsive: null,
                        rows: 1,
                        rtl: false,
                        slide: '',
                        slidesPerRow: 1,
                        slidesToShow: 1,
                        slidesToScroll: 1,
                        speed: 500,
                        swipe: true,
                        swipeToSlide: false,
                        touchMove: true,
                        touchThreshold: 5,
                        useCSS: true,
                        useTransform: true,
                        variableWidth: false,
                        vertical: false,
                        verticalSwiping: false,
                        waitForAnimate: true,
                        zIndex: 1000
                    };

                    _.initials = {
                        animating: false,
                        dragging: false,
                        autoPlayTimer: null,
                        currentDirection: 0,
                        currentLeft: null,
                        currentSlide: 0,
                        direction: 1,
                        $dots: null,
                        listWidth: null,
                        listHeight: null,
                        loadIndex: 0,
                        $nextArrow: null,
                        $prevArrow: null,
                        slideCount: null,
                        slideWidth: null,
                        $slideTrack: null,
                        $slides: null,
                        sliding: false,
                        slideOffset: 0,
                        swipeLeft: null,
                        $list: null,
                        touchObject: {},
                        transformsEnabled: false,
                        unslicked: false
                    };

                    $.extend(_, _.initials);

                    _.activeBreakpoint = null;
                    _.animType = null;
                    _.animProp = null;
                    _.breakpoints = [];
                    _.breakpointSettings = [];
                    _.cssTransitions = false;
                    _.focussed = false;
                    _.interrupted = false;
                    _.hidden = 'hidden';
                    _.paused = true;
                    _.positionProp = null;
                    _.respondTo = null;
                    _.rowCount = 1;
                    _.shouldClick = true;
                    _.$slider = $(element);
                    _.$slidesCache = null;
                    _.transformType = null;
                    _.transitionType = null;
                    _.visibilityChange = 'visibilitychange';
                    _.windowWidth = 0;
                    _.windowTimer = null;

                    dataSettings = $(element).data('slick') || {};

                    _.options = $.extend({}, _.defaults, settings, dataSettings);

                    _.currentSlide = _.options.initialSlide;

                    _.originalSettings = _.options;

                    if (typeof document.mozHidden !== 'undefined') {
                        _.hidden = 'mozHidden';
                        _.visibilityChange = 'mozvisibilitychange';
                    } else if (typeof document.webkitHidden !== 'undefined') {
                        _.hidden = 'webkitHidden';
                        _.visibilityChange = 'webkitvisibilitychange';
                    }

                    _.autoPlay = $.proxy(_.autoPlay, _);
                    _.autoPlayClear = $.proxy(_.autoPlayClear, _);
                    _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
                    _.changeSlide = $.proxy(_.changeSlide, _);
                    _.clickHandler = $.proxy(_.clickHandler, _);
                    _.selectHandler = $.proxy(_.selectHandler, _);
                    _.setPosition = $.proxy(_.setPosition, _);
                    _.swipeHandler = $.proxy(_.swipeHandler, _);
                    _.dragHandler = $.proxy(_.dragHandler, _);
                    _.keyHandler = $.proxy(_.keyHandler, _);

                    _.instanceUid = instanceUid++;

                    // A simple way to check for HTML strings
                    // Strict HTML recognition (must start with <)
                    // Extracted from jQuery v1.11 source
                    _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;


                    _.registerBreakpoints();
                    _.init(true);

                }

                return Slick;

            }());

            Slick.prototype.activateADA = function () {
                var _ = this;

                _.$slideTrack.find('.slick-active').attr({
                    'aria-hidden': 'false'
                }).find('a, input, button, select').attr({
                    'tabindex': '0'
                });

            };

            Slick.prototype.addSlide = Slick.prototype.slickAdd = function (markup, index, addBefore) {

                var _ = this;

                if (typeof (index) === 'boolean') {
                    addBefore = index;
                    index = null;
                } else if (index < 0 || (index >= _.slideCount)) {
                    return false;
                }

                _.unload();

                if (typeof (index) === 'number') {
                    if (index === 0 && _.$slides.length === 0) {
                        $(markup).appendTo(_.$slideTrack);
                    } else if (addBefore) {
                        $(markup).insertBefore(_.$slides.eq(index));
                    } else {
                        $(markup).insertAfter(_.$slides.eq(index));
                    }
                } else {
                    if (addBefore === true) {
                        $(markup).prependTo(_.$slideTrack);
                    } else {
                        $(markup).appendTo(_.$slideTrack);
                    }
                }

                _.$slides = _.$slideTrack.children(this.options.slide);

                _.$slideTrack.children(this.options.slide).detach();

                _.$slideTrack.append(_.$slides);

                _.$slides.each(function (index, element) {
                    $(element).attr('data-slick-index', index);
                });

                _.$slidesCache = _.$slides;

                _.reinit();

            };

            Slick.prototype.animateHeight = function () {
                var _ = this;
                if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
                    var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
                    _.$list.animate({
                        height: targetHeight
                    }, _.options.speed);
                }
            };

            Slick.prototype.animateSlide = function (targetLeft, callback) {

                var animProps = {},
                    _ = this;

                _.animateHeight();

                if (_.options.rtl === true && _.options.vertical === false) {
                    targetLeft = -targetLeft;
                }
                if (_.transformsEnabled === false) {
                    if (_.options.vertical === false) {
                        _.$slideTrack.animate({
                            left: targetLeft
                        }, _.options.speed, _.options.easing, callback);
                    } else {
                        _.$slideTrack.animate({
                            top: targetLeft
                        }, _.options.speed, _.options.easing, callback);
                    }

                } else {

                    if (_.cssTransitions === false) {
                        if (_.options.rtl === true) {
                            _.currentLeft = -(_.currentLeft);
                        }
                        $({
                            animStart: _.currentLeft
                        }).animate({
                            animStart: targetLeft
                        }, {
                            duration: _.options.speed,
                            easing: _.options.easing,
                            step: function (now) {
                                now = Math.ceil(now);
                                if (_.options.vertical === false) {
                                    animProps[_.animType] = 'translate(' +
                                        now + 'px, 0px)';
                                    _.$slideTrack.css(animProps);
                                } else {
                                    animProps[_.animType] = 'translate(0px,' +
                                        now + 'px)';
                                    _.$slideTrack.css(animProps);
                                }
                            },
                            complete: function () {
                                if (callback) {
                                    callback.call();
                                }
                            }
                        });

                    } else {

                        _.applyTransition();
                        targetLeft = Math.ceil(targetLeft);

                        if (_.options.vertical === false) {
                            animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
                        } else {
                            animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
                        }
                        _.$slideTrack.css(animProps);

                        if (callback) {
                            setTimeout(function () {

                                _.disableTransition();

                                callback.call();
                            }, _.options.speed);
                        }

                    }

                }

            };

            Slick.prototype.getNavTarget = function () {

                var _ = this,
                    asNavFor = _.options.asNavFor;

                if (asNavFor && asNavFor !== null) {
                    asNavFor = $(asNavFor).not(_.$slider);
                }

                return asNavFor;

            };

            Slick.prototype.asNavFor = function (index) {

                var _ = this,
                    asNavFor = _.getNavTarget();

                if (asNavFor !== null && typeof asNavFor === 'object') {
                    asNavFor.each(function () {
                        var target = $(this).slick('getSlick');
                        if (!target.unslicked) {
                            target.slideHandler(index, true);
                        }
                    });
                }

            };

            Slick.prototype.applyTransition = function (slide) {

                var _ = this,
                    transition = {};

                if (_.options.fade === false) {
                    transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
                } else {
                    transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
                }

                if (_.options.fade === false) {
                    _.$slideTrack.css(transition);
                } else {
                    _.$slides.eq(slide).css(transition);
                }

            };

            Slick.prototype.autoPlay = function () {

                var _ = this;

                _.autoPlayClear();

                if (_.slideCount > _.options.slidesToShow) {
                    _.autoPlayTimer = setInterval(_.autoPlayIterator, _.options.autoplaySpeed);
                }

            };

            Slick.prototype.autoPlayClear = function () {

                var _ = this;

                if (_.autoPlayTimer) {
                    clearInterval(_.autoPlayTimer);
                }

            };

            Slick.prototype.autoPlayIterator = function () {

                var _ = this,
                    slideTo = _.currentSlide + _.options.slidesToScroll;

                if (!_.paused && !_.interrupted && !_.focussed) {

                    if (_.options.infinite === false) {

                        if (_.direction === 1 && (_.currentSlide + 1) === (_.slideCount - 1)) {
                            _.direction = 0;
                        }

                        else if (_.direction === 0) {

                            slideTo = _.currentSlide - _.options.slidesToScroll;

                            if (_.currentSlide - 1 === 0) {
                                _.direction = 1;
                            }

                        }

                    }

                    _.slideHandler(slideTo);

                }

            };

            Slick.prototype.buildArrows = function () {

                var _ = this;

                if (_.options.arrows === true) {

                    _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
                    _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');

                    if (_.slideCount > _.options.slidesToShow) {

                        _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
                        _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');

                        if (_.htmlExpr.test(_.options.prevArrow)) {
                            _.$prevArrow.prependTo(_.options.appendArrows);
                        }

                        if (_.htmlExpr.test(_.options.nextArrow)) {
                            _.$nextArrow.appendTo(_.options.appendArrows);
                        }

                        if (_.options.infinite !== true) {
                            _.$prevArrow
                                .addClass('slick-disabled')
                                .attr('aria-disabled', 'true');
                        }

                    } else {

                        _.$prevArrow.add(_.$nextArrow)

                            .addClass('slick-hidden')
                            .attr({
                                'aria-disabled': 'true',
                                'tabindex': '-1'
                            });

                    }

                }

            };

            Slick.prototype.buildDots = function () {

                var _ = this,
                    i, dot;

                if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {

                    _.$slider.addClass('slick-dotted');

                    dot = $('<ul />').addClass(_.options.dotsClass);

                    for (i = 0; i <= _.getDotCount(); i += 1) {
                        dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
                    }

                    _.$dots = dot.appendTo(_.options.appendDots);

                    _.$dots.find('li').first().addClass('slick-active').attr('aria-hidden', 'false');

                }

            };

            Slick.prototype.buildOut = function () {

                var _ = this;

                _.$slides =
                    _.$slider
                        .children(_.options.slide + ':not(.slick-cloned)')
                        .addClass('slick-slide');

                _.slideCount = _.$slides.length;

                _.$slides.each(function (index, element) {
                    $(element)
                        .attr('data-slick-index', index)
                        .data('originalStyling', $(element).attr('style') || '');
                });

                _.$slider.addClass('slick-slider');

                _.$slideTrack = (_.slideCount === 0) ?
                    $('<div class="slick-track"/>').appendTo(_.$slider) :
                    _.$slides.wrapAll('<div class="slick-track"/>').parent();

                _.$list = _.$slideTrack.wrap(
                    '<div aria-live="polite" class="slick-list"/>').parent();
                _.$slideTrack.css('opacity', 0);

                if (_.options.centerMode === true || _.options.swipeToSlide === true) {
                    _.options.slidesToScroll = 1;
                }

                $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');

                _.setupInfinite();

                _.buildArrows();

                _.buildDots();

                _.updateDots();


                _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);

                if (_.options.draggable === true) {
                    _.$list.addClass('draggable');
                }

            };

            Slick.prototype.buildRows = function () {

                var _ = this, a, b, c, newSlides, numOfSlides, originalSlides, slidesPerSection;

                newSlides = document.createDocumentFragment();
                originalSlides = _.$slider.children();

                if (_.options.rows > 1) {

                    slidesPerSection = _.options.slidesPerRow * _.options.rows;
                    numOfSlides = Math.ceil(
                        originalSlides.length / slidesPerSection
                    );

                    for (a = 0; a < numOfSlides; a++) {
                        var slide = document.createElement('div');
                        for (b = 0; b < _.options.rows; b++) {
                            var row = document.createElement('div');
                            for (c = 0; c < _.options.slidesPerRow; c++) {
                                var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
                                if (originalSlides.get(target)) {
                                    row.appendChild(originalSlides.get(target));
                                }
                            }
                            slide.appendChild(row);
                        }
                        newSlides.appendChild(slide);
                    }

                    _.$slider.empty().append(newSlides);
                    _.$slider.children().children().children()
                        .css({
                            'width': (100 / _.options.slidesPerRow) + '%',
                            'display': 'inline-block'
                        });

                }

            };

            Slick.prototype.checkResponsive = function (initial, forceUpdate) {

                var _ = this,
                    breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
                var sliderWidth = _.$slider.width();
                var windowWidth = window.innerWidth || $(window).width();

                if (_.respondTo === 'window') {
                    respondToWidth = windowWidth;
                } else if (_.respondTo === 'slider') {
                    respondToWidth = sliderWidth;
                } else if (_.respondTo === 'min') {
                    respondToWidth = Math.min(windowWidth, sliderWidth);
                }

                if (_.options.responsive &&
                    _.options.responsive.length &&
                    _.options.responsive !== null) {

                    targetBreakpoint = null;

                    for (breakpoint in _.breakpoints) {
                        if (_.breakpoints.hasOwnProperty(breakpoint)) {
                            if (_.originalSettings.mobileFirst === false) {
                                if (respondToWidth < _.breakpoints[breakpoint]) {
                                    targetBreakpoint = _.breakpoints[breakpoint];
                                }
                            } else {
                                if (respondToWidth > _.breakpoints[breakpoint]) {
                                    targetBreakpoint = _.breakpoints[breakpoint];
                                }
                            }
                        }
                    }

                    if (targetBreakpoint !== null) {
                        if (_.activeBreakpoint !== null) {
                            if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
                                _.activeBreakpoint =
                                    targetBreakpoint;
                                if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
                                    _.unslick(targetBreakpoint);
                                } else {
                                    _.options = $.extend({}, _.originalSettings,
                                        _.breakpointSettings[
                                        targetBreakpoint]);
                                    if (initial === true) {
                                        _.currentSlide = _.options.initialSlide;
                                    }
                                    _.refresh(initial);
                                }
                                triggerBreakpoint = targetBreakpoint;
                            }
                        } else {
                            _.activeBreakpoint = targetBreakpoint;
                            if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
                                _.unslick(targetBreakpoint);
                            } else {
                                _.options = $.extend({}, _.originalSettings,
                                    _.breakpointSettings[
                                    targetBreakpoint]);
                                if (initial === true) {
                                    _.currentSlide = _.options.initialSlide;
                                }
                                _.refresh(initial);
                            }
                            triggerBreakpoint = targetBreakpoint;
                        }
                    } else {
                        if (_.activeBreakpoint !== null) {
                            _.activeBreakpoint = null;
                            _.options = _.originalSettings;
                            if (initial === true) {
                                _.currentSlide = _.options.initialSlide;
                            }
                            _.refresh(initial);
                            triggerBreakpoint = targetBreakpoint;
                        }
                    }

                    // only trigger breakpoints during an actual break. not on initialize.
                    if (!initial && triggerBreakpoint !== false) {
                        _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
                    }
                }

            };

            Slick.prototype.changeSlide = function (event, dontAnimate) {

                var _ = this,
                    $target = $(event.currentTarget),
                    indexOffset, slideOffset, unevenOffset;

                // If target is a link, prevent default action.
                if ($target.is('a')) {
                    event.preventDefault();
                }

                // If target is not the <li> element (ie: a child), find the <li>.
                if (!$target.is('li')) {
                    $target = $target.closest('li');
                }

                unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
                indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;

                switch (event.data.message) {

                    case 'previous':
                        slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
                        if (_.slideCount > _.options.slidesToShow) {
                            _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
                        }
                        break;

                    case 'next':
                        slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
                        if (_.slideCount > _.options.slidesToShow) {
                            _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
                        }
                        break;

                    case 'index':
                        var index = event.data.index === 0 ? 0 :
                            event.data.index || $target.index() * _.options.slidesToScroll;

                        _.slideHandler(_.checkNavigable(index), false, dontAnimate);
                        $target.children().trigger('focus');
                        break;

                    default:
                        return;
                }

            };

            Slick.prototype.checkNavigable = function (index) {

                var _ = this,
                    navigables, prevNavigable;

                navigables = _.getNavigableIndexes();
                prevNavigable = 0;
                if (index > navigables[navigables.length - 1]) {
                    index = navigables[navigables.length - 1];
                } else {
                    for (var n in navigables) {
                        if (index < navigables[n]) {
                            index = prevNavigable;
                            break;
                        }
                        prevNavigable = navigables[n];
                    }
                }

                return index;
            };

            Slick.prototype.cleanUpEvents = function () {

                var _ = this;

                if (_.options.dots && _.$dots !== null) {

                    $('li', _.$dots)
                        .off('click.slick', _.changeSlide)
                        .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
                        .off('mouseleave.slick', $.proxy(_.interrupt, _, false));

                }

                _.$slider.off('focus.slick blur.slick');

                if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
                    _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
                    _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
                }

                _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
                _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
                _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
                _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);

                _.$list.off('click.slick', _.clickHandler);

                $(document).off(_.visibilityChange, _.visibility);

                _.cleanUpSlideEvents();

                if (_.options.accessibility === true) {
                    _.$list.off('keydown.slick', _.keyHandler);
                }

                if (_.options.focusOnSelect === true) {
                    $(_.$slideTrack).children().off('click.slick', _.selectHandler);
                }

                $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);

                $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);

                $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);

                $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
                $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);

            };

            Slick.prototype.cleanUpSlideEvents = function () {

                var _ = this;

                _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
                _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));

            };

            Slick.prototype.cleanUpRows = function () {

                var _ = this, originalSlides;

                if (_.options.rows > 1) {
                    originalSlides = _.$slides.children().children();
                    originalSlides.removeAttr('style');
                    _.$slider.empty().append(originalSlides);
                }

            };

            Slick.prototype.clickHandler = function (event) {

                var _ = this;

                if (_.shouldClick === false) {
                    event.stopImmediatePropagation();
                    event.stopPropagation();
                    event.preventDefault();
                }

            };

            Slick.prototype.destroy = function (refresh) {

                var _ = this;

                _.autoPlayClear();

                _.touchObject = {};

                _.cleanUpEvents();

                $('.slick-cloned', _.$slider).detach();

                if (_.$dots) {
                    _.$dots.remove();
                }


                if (_.$prevArrow && _.$prevArrow.length) {

                    _.$prevArrow
                        .removeClass('slick-disabled slick-arrow slick-hidden')
                        .removeAttr('aria-hidden aria-disabled tabindex')
                        .css('display', '');

                    if (_.htmlExpr.test(_.options.prevArrow)) {
                        _.$prevArrow.remove();
                    }
                }

                if (_.$nextArrow && _.$nextArrow.length) {

                    _.$nextArrow
                        .removeClass('slick-disabled slick-arrow slick-hidden')
                        .removeAttr('aria-hidden aria-disabled tabindex')
                        .css('display', '');

                    if (_.htmlExpr.test(_.options.nextArrow)) {
                        _.$nextArrow.remove();
                    }

                }


                if (_.$slides) {

                    _.$slides
                        .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
                        .removeAttr('aria-hidden')
                        .removeAttr('data-slick-index')
                        .each(function () {
                            $(this).attr('style', $(this).data('originalStyling'));
                        });

                    _.$slideTrack.children(this.options.slide).detach();

                    _.$slideTrack.detach();

                    _.$list.detach();

                    _.$slider.append(_.$slides);
                }

                _.cleanUpRows();

                _.$slider.removeClass('slick-slider');
                _.$slider.removeClass('slick-initialized');
                _.$slider.removeClass('slick-dotted');

                _.unslicked = true;

                if (!refresh) {
                    _.$slider.trigger('destroy', [_]);
                }

            };

            Slick.prototype.disableTransition = function (slide) {

                var _ = this,
                    transition = {};

                transition[_.transitionType] = '';

                if (_.options.fade === false) {
                    _.$slideTrack.css(transition);
                } else {
                    _.$slides.eq(slide).css(transition);
                }

            };

            Slick.prototype.fadeSlide = function (slideIndex, callback) {

                var _ = this;

                if (_.cssTransitions === false) {

                    _.$slides.eq(slideIndex).css({
                        zIndex: _.options.zIndex
                    });

                    _.$slides.eq(slideIndex).animate({
                        opacity: 1
                    }, _.options.speed, _.options.easing, callback);

                } else {

                    _.applyTransition(slideIndex);

                    _.$slides.eq(slideIndex).css({
                        opacity: 1,
                        zIndex: _.options.zIndex
                    });

                    if (callback) {
                        setTimeout(function () {

                            _.disableTransition(slideIndex);

                            callback.call();
                        }, _.options.speed);
                    }

                }

            };

            Slick.prototype.fadeSlideOut = function (slideIndex) {

                var _ = this;

                if (_.cssTransitions === false) {

                    _.$slides.eq(slideIndex).animate({
                        opacity: 0,
                        zIndex: _.options.zIndex - 2
                    }, _.options.speed, _.options.easing);

                } else {

                    _.applyTransition(slideIndex);

                    _.$slides.eq(slideIndex).css({
                        opacity: 0,
                        zIndex: _.options.zIndex - 2
                    });

                }

            };

            Slick.prototype.filterSlides = Slick.prototype.slickFilter = function (filter) {

                var _ = this;

                if (filter !== null) {

                    _.$slidesCache = _.$slides;

                    _.unload();

                    _.$slideTrack.children(this.options.slide).detach();

                    _.$slidesCache.filter(filter).appendTo(_.$slideTrack);

                    _.reinit();

                }

            };

            Slick.prototype.focusHandler = function () {

                var _ = this;

                _.$slider
                    .off('focus.slick blur.slick')
                    .on('focus.slick blur.slick',
                        '*:not(.slick-arrow)', function (event) {

                            event.stopImmediatePropagation();
                            var $sf = $(this);

                            setTimeout(function () {

                                if (_.options.pauseOnFocus) {
                                    _.focussed = $sf.is(':focus');
                                    _.autoPlay();
                                }

                            }, 0);

                        });
            };

            Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function () {

                var _ = this;
                return _.currentSlide;

            };

            Slick.prototype.getDotCount = function () {

                var _ = this;

                var breakPoint = 0;
                var counter = 0;
                var pagerQty = 0;

                if (_.options.infinite === true) {
                    while (breakPoint < _.slideCount) {
                        ++pagerQty;
                        breakPoint = counter + _.options.slidesToScroll;
                        counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
                    }
                } else if (_.options.centerMode === true) {
                    pagerQty = _.slideCount;
                } else if (!_.options.asNavFor) {
                    pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);
                } else {
                    while (breakPoint < _.slideCount) {
                        ++pagerQty;
                        breakPoint = counter + _.options.slidesToScroll;
                        counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
                    }
                }

                return pagerQty - 1;

            };

            Slick.prototype.getLeft = function (slideIndex) {

                var _ = this,
                    targetLeft,
                    verticalHeight,
                    verticalOffset = 0,
                    targetSlide;

                _.slideOffset = 0;
                verticalHeight = _.$slides.first().outerHeight(true);

                if (_.options.infinite === true) {
                    if (_.slideCount > _.options.slidesToShow) {
                        _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
                        verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
                    }
                    if (_.slideCount % _.options.slidesToScroll !== 0) {
                        if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
                            if (slideIndex > _.slideCount) {
                                _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
                                verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
                            } else {
                                _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
                                verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
                            }
                        }
                    }
                } else {
                    if (slideIndex + _.options.slidesToShow > _.slideCount) {
                        _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
                        verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
                    }
                }

                if (_.slideCount <= _.options.slidesToShow) {
                    _.slideOffset = 0;
                    verticalOffset = 0;
                }

                if (_.options.centerMode === true && _.options.infinite === true) {
                    _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
                } else if (_.options.centerMode === true) {
                    _.slideOffset = 0;
                    _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
                }

                if (_.options.vertical === false) {
                    targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
                } else {
                    targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
                }

                if (_.options.variableWidth === true) {

                    if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
                        targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
                    } else {
                        targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
                    }

                    if (_.options.rtl === true) {
                        if (targetSlide[0]) {
                            targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
                        } else {
                            targetLeft = 0;
                        }
                    } else {
                        targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
                    }

                    if (_.options.centerMode === true) {
                        if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
                            targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
                        } else {
                            targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
                        }

                        if (_.options.rtl === true) {
                            if (targetSlide[0]) {
                                targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
                            } else {
                                targetLeft = 0;
                            }
                        } else {
                            targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
                        }

                        targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
                    }
                }

                return targetLeft;

            };

            Slick.prototype.getOption = Slick.prototype.slickGetOption = function (option) {

                var _ = this;

                return _.options[option];

            };

            Slick.prototype.getNavigableIndexes = function () {

                var _ = this,
                    breakPoint = 0,
                    counter = 0,
                    indexes = [],
                    max;

                if (_.options.infinite === false) {
                    max = _.slideCount;
                } else {
                    breakPoint = _.options.slidesToScroll * -1;
                    counter = _.options.slidesToScroll * -1;
                    max = _.slideCount * 2;
                }

                while (breakPoint < max) {
                    indexes.push(breakPoint);
                    breakPoint = counter + _.options.slidesToScroll;
                    counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
                }

                return indexes;

            };

            Slick.prototype.getSlick = function () {

                return this;

            };

            Slick.prototype.getSlideCount = function () {

                var _ = this,
                    slidesTraversed, swipedSlide, centerOffset;

                centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;

                if (_.options.swipeToSlide === true) {
                    _.$slideTrack.find('.slick-slide').each(function (index, slide) {
                        if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
                            swipedSlide = slide;
                            return false;
                        }
                    });

                    slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;

                    return slidesTraversed;

                } else {
                    return _.options.slidesToScroll;
                }

            };

            Slick.prototype.goTo = Slick.prototype.slickGoTo = function (slide, dontAnimate) {

                var _ = this;

                _.changeSlide({
                    data: {
                        message: 'index',
                        index: parseInt(slide)
                    }
                }, dontAnimate);

            };

            Slick.prototype.init = function (creation) {

                var _ = this;

                if (!$(_.$slider).hasClass('slick-initialized')) {

                    $(_.$slider).addClass('slick-initialized');

                    _.buildRows();
                    _.buildOut();
                    _.setProps();
                    _.startLoad();
                    _.loadSlider();
                    _.initializeEvents();
                    _.updateArrows();
                    _.updateDots();
                    _.checkResponsive(true);
                    _.focusHandler();

                }

                if (creation) {
                    _.$slider.trigger('init', [_]);
                }

                if (_.options.accessibility === true) {
                    _.initADA();
                }

                if (_.options.autoplay) {

                    _.paused = false;
                    _.autoPlay();

                }

            };

            Slick.prototype.initADA = function () {
                var _ = this;
                _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({
                    'aria-hidden': 'true',
                    'tabindex': '-1'
                }).find('a, input, button, select').attr({
                    'tabindex': '-1'
                });

                _.$slideTrack.attr('role', 'listbox');

                _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function (i) {
                    $(this).attr({
                        'role': 'option',
                        'aria-describedby': 'slick-slide' + _.instanceUid + i + ''
                    });
                });

                if (_.$dots !== null) {
                    _.$dots.attr('role', 'tablist').find('li').each(function (i) {
                        $(this).attr({
                            'role': 'presentation',
                            'aria-selected': 'false',
                            'aria-controls': 'navigation' + _.instanceUid + i + '',
                            'id': 'slick-slide' + _.instanceUid + i + ''
                        });
                    })
                        .first().attr('aria-selected', 'true').end()
                        .find('button').attr('role', 'button').end()
                        .closest('div').attr('role', 'toolbar');
                }
                _.activateADA();

            };

            Slick.prototype.initArrowEvents = function () {

                var _ = this;

                if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
                    _.$prevArrow
                        .off('click.slick')
                        .on('click.slick', {
                            message: 'previous'
                        }, _.changeSlide);
                    _.$nextArrow
                        .off('click.slick')
                        .on('click.slick', {
                            message: 'next'
                        }, _.changeSlide);
                }

            };

            Slick.prototype.initDotEvents = function () {

                var _ = this;

                if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
                    $('li', _.$dots).on('click.slick', {
                        message: 'index'
                    }, _.changeSlide);
                }

                if (_.options.dots === true && _.options.pauseOnDotsHover === true) {

                    $('li', _.$dots)
                        .on('mouseenter.slick', $.proxy(_.interrupt, _, true))
                        .on('mouseleave.slick', $.proxy(_.interrupt, _, false));

                }

            };

            Slick.prototype.initSlideEvents = function () {

                var _ = this;

                if (_.options.pauseOnHover) {

                    _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));
                    _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));

                }

            };

            Slick.prototype.initializeEvents = function () {

                var _ = this;

                _.initArrowEvents();

                _.initDotEvents();
                _.initSlideEvents();

                _.$list.on('touchstart.slick mousedown.slick', {
                    action: 'start'
                }, _.swipeHandler);
                _.$list.on('touchmove.slick mousemove.slick', {
                    action: 'move'
                }, _.swipeHandler);
                _.$list.on('touchend.slick mouseup.slick', {
                    action: 'end'
                }, _.swipeHandler);
                _.$list.on('touchcancel.slick mouseleave.slick', {
                    action: 'end'
                }, _.swipeHandler);

                _.$list.on('click.slick', _.clickHandler);

                $(document).on(_.visibilityChange, $.proxy(_.visibility, _));

                if (_.options.accessibility === true) {
                    _.$list.on('keydown.slick', _.keyHandler);
                }

                if (_.options.focusOnSelect === true) {
                    $(_.$slideTrack).children().on('click.slick', _.selectHandler);
                }

                $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));

                $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));

                $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);

                $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
                $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);

            };

            Slick.prototype.initUI = function () {

                var _ = this;

                if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {

                    _.$prevArrow.show();
                    _.$nextArrow.show();

                }

                if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {

                    _.$dots.show();

                }

            };

            Slick.prototype.keyHandler = function (event) {

                var _ = this;
                //Dont slide if the cursor is inside the form fields and arrow keys are pressed
                if (!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
                    if (event.keyCode === 37 && _.options.accessibility === true) {
                        _.changeSlide({
                            data: {
                                message: _.options.rtl === true ? 'next' : 'previous'
                            }
                        });
                    } else if (event.keyCode === 39 && _.options.accessibility === true) {
                        _.changeSlide({
                            data: {
                                message: _.options.rtl === true ? 'previous' : 'next'
                            }
                        });
                    }
                }

            };

            Slick.prototype.lazyLoad = function () {

                var _ = this,
                    loadRange, cloneRange, rangeStart, rangeEnd;

                function loadImages(imagesScope) {

                    $('img[data-lazy]', imagesScope).each(function () {

                        var image = $(this),
                            imageSource = $(this).attr('data-lazy'),
                            imageToLoad = document.createElement('img');

                        imageToLoad.onload = function () {

                            image
                                .animate({ opacity: 0 }, 100, function () {
                                    image
                                        .attr('src', imageSource)
                                        .animate({ opacity: 1 }, 200, function () {
                                            image
                                                .removeAttr('data-lazy')
                                                .removeClass('slick-loading');
                                        });
                                    _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
                                });

                        };

                        imageToLoad.onerror = function () {

                            image
                                .removeAttr('data-lazy')
                                .removeClass('slick-loading')
                                .addClass('slick-lazyload-error');

                            _.$slider.trigger('lazyLoadError', [_, image, imageSource]);

                        };

                        imageToLoad.src = imageSource;

                    });

                }

                if (_.options.centerMode === true) {
                    if (_.options.infinite === true) {
                        rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
                        rangeEnd = rangeStart + _.options.slidesToShow + 2;
                    } else {
                        rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
                        rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
                    }
                } else {
                    rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
                    rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
                    if (_.options.fade === true) {
                        if (rangeStart > 0) rangeStart--;
                        if (rangeEnd <= _.slideCount) rangeEnd++;
                    }
                }

                loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
                loadImages(loadRange);

                if (_.slideCount <= _.options.slidesToShow) {
                    cloneRange = _.$slider.find('.slick-slide');
                    loadImages(cloneRange);
                } else
                    if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
                        cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
                        loadImages(cloneRange);
                    } else if (_.currentSlide === 0) {
                        cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
                        loadImages(cloneRange);
                    }

            };

            Slick.prototype.loadSlider = function () {

                var _ = this;

                _.setPosition();

                _.$slideTrack.css({
                    opacity: 1
                });

                _.$slider.removeClass('slick-loading');

                _.initUI();

                if (_.options.lazyLoad === 'progressive') {
                    _.progressiveLazyLoad();
                }

            };

            Slick.prototype.next = Slick.prototype.slickNext = function () {

                var _ = this;

                _.changeSlide({
                    data: {
                        message: 'next'
                    }
                });

            };

            Slick.prototype.orientationChange = function () {

                var _ = this;

                _.checkResponsive();
                _.setPosition();

            };

            Slick.prototype.pause = Slick.prototype.slickPause = function () {

                var _ = this;

                _.autoPlayClear();
                _.paused = true;

            };

            Slick.prototype.play = Slick.prototype.slickPlay = function () {

                var _ = this;

                _.autoPlay();
                _.options.autoplay = true;
                _.paused = false;
                _.focussed = false;
                _.interrupted = false;

            };

            Slick.prototype.postSlide = function (index) {

                var _ = this;

                if (!_.unslicked) {

                    _.$slider.trigger('afterChange', [_, index]);

                    _.animating = false;

                    _.setPosition();

                    _.swipeLeft = null;

                    if (_.options.autoplay) {
                        _.autoPlay();
                    }

                    if (_.options.accessibility === true) {
                        _.initADA();
                    }

                }

            };

            Slick.prototype.prev = Slick.prototype.slickPrev = function () {

                var _ = this;

                _.changeSlide({
                    data: {
                        message: 'previous'
                    }
                });

            };

            Slick.prototype.preventDefault = function (event) {

                event.preventDefault();

            };

            Slick.prototype.progressiveLazyLoad = function (tryCount) {

                tryCount = tryCount || 1;

                var _ = this,
                    $imgsToLoad = $('img[data-lazy]', _.$slider),
                    image,
                    imageSource,
                    imageToLoad;

                if ($imgsToLoad.length) {

                    image = $imgsToLoad.first();
                    imageSource = image.attr('data-lazy');
                    imageToLoad = document.createElement('img');

                    imageToLoad.onload = function () {

                        image
                            .attr('src', imageSource)
                            .removeAttr('data-lazy')
                            .removeClass('slick-loading');

                        if (_.options.adaptiveHeight === true) {
                            _.setPosition();
                        }

                        _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
                        _.progressiveLazyLoad();

                    };

                    imageToLoad.onerror = function () {

                        if (tryCount < 3) {

                            /**
                             * try to load the image 3 times,
                             * leave a slight delay so we don't get
                             * servers blocking the request.
                             */
                            setTimeout(function () {
                                _.progressiveLazyLoad(tryCount + 1);
                            }, 500);

                        } else {

                            image
                                .removeAttr('data-lazy')
                                .removeClass('slick-loading')
                                .addClass('slick-lazyload-error');

                            _.$slider.trigger('lazyLoadError', [_, image, imageSource]);

                            _.progressiveLazyLoad();

                        }

                    };

                    imageToLoad.src = imageSource;

                } else {

                    _.$slider.trigger('allImagesLoaded', [_]);

                }

            };

            Slick.prototype.refresh = function (initializing) {

                var _ = this, currentSlide, lastVisibleIndex;

                lastVisibleIndex = _.slideCount - _.options.slidesToShow;

                // in non-infinite sliders, we don't want to go past the
                // last visible index.
                if (!_.options.infinite && (_.currentSlide > lastVisibleIndex)) {
                    _.currentSlide = lastVisibleIndex;
                }

                // if less slides than to show, go to start.
                if (_.slideCount <= _.options.slidesToShow) {
                    _.currentSlide = 0;

                }

                currentSlide = _.currentSlide;

                _.destroy(true);

                $.extend(_, _.initials, { currentSlide: currentSlide });

                _.init();

                if (!initializing) {

                    _.changeSlide({
                        data: {
                            message: 'index',
                            index: currentSlide
                        }
                    }, false);

                }

            };

            Slick.prototype.registerBreakpoints = function () {

                var _ = this, breakpoint, currentBreakpoint, l,
                    responsiveSettings = _.options.responsive || null;

                if ($.type(responsiveSettings) === 'array' && responsiveSettings.length) {

                    _.respondTo = _.options.respondTo || 'window';

                    for (breakpoint in responsiveSettings) {

                        l = _.breakpoints.length - 1;
                        currentBreakpoint = responsiveSettings[breakpoint].breakpoint;

                        if (responsiveSettings.hasOwnProperty(breakpoint)) {

                            // loop through the breakpoints and cut out any existing
                            // ones with the same breakpoint number, we don't want dupes.
                            while (l >= 0) {
                                if (_.breakpoints[l] && _.breakpoints[l] === currentBreakpoint) {
                                    _.breakpoints.splice(l, 1);
                                }
                                l--;
                            }

                            _.breakpoints.push(currentBreakpoint);
                            _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;

                        }

                    }

                    _.breakpoints.sort(function (a, b) {
                        return (_.options.mobileFirst) ? a - b : b - a;
                    });

                }

            };

            Slick.prototype.reinit = function () {

                var _ = this;

                _.$slides =
                    _.$slideTrack
                        .children(_.options.slide)
                        .addClass('slick-slide');

                _.slideCount = _.$slides.length;

                if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
                    _.currentSlide = _.currentSlide - _.options.slidesToScroll;
                }

                if (_.slideCount <= _.options.slidesToShow) {
                    _.currentSlide = 0;
                }

                _.registerBreakpoints();

                _.setProps();
                _.setupInfinite();
                _.buildArrows();
                _.updateArrows();
                _.initArrowEvents();
                _.buildDots();
                _.updateDots();
                _.initDotEvents();
                _.cleanUpSlideEvents();
                _.initSlideEvents();

                _.checkResponsive(false, true);

                if (_.options.focusOnSelect === true) {
                    $(_.$slideTrack).children().on('click.slick', _.selectHandler);
                }

                _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);

                _.setPosition();
                _.focusHandler();

                _.paused = !_.options.autoplay;
                _.autoPlay();

                _.$slider.trigger('reInit', [_]);

            };

            Slick.prototype.resize = function () {

                var _ = this;

                if ($(window).width() !== _.windowWidth) {
                    clearTimeout(_.windowDelay);
                    _.windowDelay = window.setTimeout(function () {
                        _.windowWidth = $(window).width();
                        _.checkResponsive();
                        if (!_.unslicked) { _.setPosition(); }
                    }, 50);
                }
            };

            Slick.prototype.removeSlide = Slick.prototype.slickRemove = function (index, removeBefore, removeAll) {

                var _ = this;

                if (typeof (index) === 'boolean') {
                    removeBefore = index;
                    index = removeBefore === true ? 0 : _.slideCount - 1;
                } else {
                    index = removeBefore === true ? --index : index;
                }

                if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
                    return false;
                }

                _.unload();

                if (removeAll === true) {
                    _.$slideTrack.children().remove();
                } else {
                    _.$slideTrack.children(this.options.slide).eq(index).remove();
                }

                _.$slides = _.$slideTrack.children(this.options.slide);

                _.$slideTrack.children(this.options.slide).detach();

                _.$slideTrack.append(_.$slides);

                _.$slidesCache = _.$slides;

                _.reinit();

            };

            Slick.prototype.setCSS = function (position) {

                var _ = this,
                    positionProps = {},
                    x, y;

                if (_.options.rtl === true) {
                    position = -position;
                }
                x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
                y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';

                positionProps[_.positionProp] = position;

                if (_.transformsEnabled === false) {
                    _.$slideTrack.css(positionProps);
                } else {
                    positionProps = {};
                    if (_.cssTransitions === false) {
                        positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
                        _.$slideTrack.css(positionProps);
                    } else {
                        positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
                        _.$slideTrack.css(positionProps);
                    }
                }

            };

            Slick.prototype.setDimensions = function () {

                var _ = this;

                if (_.options.vertical === false) {
                    if (_.options.centerMode === true) {
                        _.$list.css({
                            padding: ('0px ' + _.options.centerPadding)
                        });
                    }
                } else {
                    _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
                    if (_.options.centerMode === true) {
                        _.$list.css({
                            padding: (_.options.centerPadding + ' 0px')
                        });
                    }
                }

                _.listWidth = _.$list.width();
                _.listHeight = _.$list.height();


                if (_.options.vertical === false && _.options.variableWidth === false) {
                    _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
                    _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));

                } else if (_.options.variableWidth === true) {
                    _.$slideTrack.width(5000 * _.slideCount);
                } else {
                    _.slideWidth = Math.ceil(_.listWidth);
                    _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
                }

                var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
                if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);

            };

            Slick.prototype.setFade = function () {

                var _ = this,
                    targetLeft;

                _.$slides.each(function (index, element) {
                    targetLeft = (_.slideWidth * index) * -1;
                    if (_.options.rtl === true) {
                        $(element).css({
                            position: 'relative',
                            right: targetLeft,
                            top: 0,
                            zIndex: _.options.zIndex - 2,
                            opacity: 0
                        });
                    } else {
                        $(element).css({
                            position: 'relative',
                            left: targetLeft,
                            top: 0,
                            zIndex: _.options.zIndex - 2,
                            opacity: 0
                        });
                    }
                });

                _.$slides.eq(_.currentSlide).css({
                    zIndex: _.options.zIndex - 1,
                    opacity: 1
                });

            };

            Slick.prototype.setHeight = function () {

                var _ = this;

                if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
                    var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
                    _.$list.css('height', targetHeight);
                }

            };

            Slick.prototype.setOption =
                Slick.prototype.slickSetOption = function () {

                    /**
                     * accepts arguments in format of:
                     *
                     *  - for changing a single option's value:
                     *     .slick("setOption", option, value, refresh )
                     *
                     *  - for changing a set of responsive options:
                     *     .slick("setOption", 'responsive', [{}, ...], refresh )
                     *
                     *  - for updating multiple values at once (not responsive)
                     *     .slick("setOption", { 'option': value, ... }, refresh )
                     */

                    var _ = this, l, item, option, value, refresh = false, type;

                    if ($.type(arguments[0]) === 'object') {

                        option = arguments[0];
                        refresh = arguments[1];
                        type = 'multiple';

                    } else if ($.type(arguments[0]) === 'string') {

                        option = arguments[0];
                        value = arguments[1];
                        refresh = arguments[2];

                        if (arguments[0] === 'responsive' && $.type(arguments[1]) === 'array') {

                            type = 'responsive';

                        } else if (typeof arguments[1] !== 'undefined') {

                            type = 'single';

                        }

                    }

                    if (type === 'single') {

                        _.options[option] = value;


                    } else if (type === 'multiple') {

                        $.each(option, function (opt, val) {

                            _.options[opt] = val;

                        });


                    } else if (type === 'responsive') {

                        for (item in value) {

                            if ($.type(_.options.responsive) !== 'array') {

                                _.options.responsive = [value[item]];

                            } else {

                                l = _.options.responsive.length - 1;

                                // loop through the responsive object and splice out duplicates.
                                while (l >= 0) {

                                    if (_.options.responsive[l].breakpoint === value[item].breakpoint) {

                                        _.options.responsive.splice(l, 1);

                                    }

                                    l--;

                                }

                                _.options.responsive.push(value[item]);

                            }

                        }

                    }

                    if (refresh) {

                        _.unload();
                        _.reinit();

                    }

                };

            Slick.prototype.setPosition = function () {

                var _ = this;

                _.setDimensions();

                _.setHeight();

                if (_.options.fade === false) {
                    _.setCSS(_.getLeft(_.currentSlide));
                } else {
                    _.setFade();
                }

                _.$slider.trigger('setPosition', [_]);

            };

            Slick.prototype.setProps = function () {

                var _ = this,
                    bodyStyle = document.body.style;

                _.positionProp = _.options.vertical === true ? 'top' : 'left';

                if (_.positionProp === 'top') {
                    _.$slider.addClass('slick-vertical');
                } else {
                    _.$slider.removeClass('slick-vertical');
                }

                if (bodyStyle.WebkitTransition !== undefined ||
                    bodyStyle.MozTransition !== undefined ||
                    bodyStyle.msTransition !== undefined) {
                    if (_.options.useCSS === true) {
                        _.cssTransitions = true;
                    }
                }

                if (_.options.fade) {
                    if (typeof _.options.zIndex === 'number') {
                        if (_.options.zIndex < 3) {
                            _.options.zIndex = 3;
                        }
                    } else {
                        _.options.zIndex = _.defaults.zIndex;
                    }
                }

                if (bodyStyle.OTransform !== undefined) {
                    _.animType = 'OTransform';
                    _.transformType = '-o-transform';
                    _.transitionType = 'OTransition';
                    if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
                }
                if (bodyStyle.MozTransform !== undefined) {
                    _.animType = 'MozTransform';
                    _.transformType = '-moz-transform';
                    _.transitionType = 'MozTransition';
                    if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
                }
                if (bodyStyle.webkitTransform !== undefined) {
                    _.animType = 'webkitTransform';
                    _.transformType = '-webkit-transform';
                    _.transitionType = 'webkitTransition';
                    if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
                }
                if (bodyStyle.msTransform !== undefined) {
                    _.animType = 'msTransform';
                    _.transformType = '-ms-transform';
                    _.transitionType = 'msTransition';
                    if (bodyStyle.msTransform === undefined) _.animType = false;
                }
                if (bodyStyle.transform !== undefined && _.animType !== false) {
                    _.animType = 'transform';
                    _.transformType = 'transform';
                    _.transitionType = 'transition';
                }
                _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
            };


            Slick.prototype.setSlideClasses = function (index) {

                var _ = this,
                    centerOffset, allSlides, indexOffset, remainder;

                allSlides = _.$slider
                    .find('.slick-slide')
                    .removeClass('slick-active slick-center slick-current')
                    .attr('aria-hidden', 'true');

                _.$slides
                    .eq(index)
                    .addClass('slick-current');

                if (_.options.centerMode === true) {

                    centerOffset = Math.floor(_.options.slidesToShow / 2);

                    if (_.options.infinite === true) {

                        if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {

                            _.$slides
                                .slice(index - centerOffset, index + centerOffset + 1)
                                .addClass('slick-active')
                                .attr('aria-hidden', 'false');

                        } else {

                            indexOffset = _.options.slidesToShow + index;
                            allSlides
                                .slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2)
                                .addClass('slick-active')
                                .attr('aria-hidden', 'false');

                        }

                        if (index === 0) {

                            allSlides
                                .eq(allSlides.length - 1 - _.options.slidesToShow)
                                .addClass('slick-center');

                        } else if (index === _.slideCount - 1) {

                            allSlides
                                .eq(_.options.slidesToShow)
                                .addClass('slick-center');

                        }

                    }

                    _.$slides
                        .eq(index)
                        .addClass('slick-center');

                } else {

                    if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {

                        _.$slides
                            .slice(index, index + _.options.slidesToShow)
                            .addClass('slick-active')
                            .attr('aria-hidden', 'false');

                    } else if (allSlides.length <= _.options.slidesToShow) {

                        allSlides
                            .addClass('slick-active')
                            .attr('aria-hidden', 'false');

                    } else {

                        remainder = _.slideCount % _.options.slidesToShow;
                        indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;

                        if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {

                            allSlides
                                .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)
                                .addClass('slick-active')
                                .attr('aria-hidden', 'false');

                        } else {

                            allSlides
                                .slice(indexOffset, indexOffset + _.options.slidesToShow)
                                .addClass('slick-active')
                                .attr('aria-hidden', 'false');

                        }

                    }

                }

                if (_.options.lazyLoad === 'ondemand') {
                    _.lazyLoad();
                }

            };

            Slick.prototype.setupInfinite = function () {

                var _ = this,
                    i, slideIndex, infiniteCount;

                if (_.options.fade === true) {
                    _.options.centerMode = false;
                }

                if (_.options.infinite === true && _.options.fade === false) {

                    slideIndex = null;

                    if (_.slideCount > _.options.slidesToShow) {

                        if (_.options.centerMode === true) {
                            infiniteCount = _.options.slidesToShow + 1;
                        } else {
                            infiniteCount = _.options.slidesToShow;
                        }

                        for (i = _.slideCount; i > (_.slideCount -
                            infiniteCount); i -= 1) {
                            slideIndex = i - 1;
                            $(_.$slides[slideIndex]).clone(true).attr('id', '')
                                .attr('data-slick-index', slideIndex - _.slideCount)
                                .prependTo(_.$slideTrack).addClass('slick-cloned');
                        }
                        for (i = 0; i < infiniteCount; i += 1) {
                            slideIndex = i;
                            $(_.$slides[slideIndex]).clone(true).attr('id', '')
                                .attr('data-slick-index', slideIndex + _.slideCount)
                                .appendTo(_.$slideTrack).addClass('slick-cloned');
                        }
                        _.$slideTrack.find('.slick-cloned').find('[id]').each(function () {
                            $(this).attr('id', '');
                        });

                    }

                }

            };

            Slick.prototype.interrupt = function (toggle) {

                var _ = this;

                if (!toggle) {
                    _.autoPlay();
                }
                _.interrupted = toggle;

            };

            Slick.prototype.selectHandler = function (event) {

                var _ = this;

                var targetElement =
                    $(event.target).is('.slick-slide') ?
                        $(event.target) :
                        $(event.target).parents('.slick-slide');

                var index = parseInt(targetElement.attr('data-slick-index'));

                if (!index) index = 0;

                if (_.slideCount <= _.options.slidesToShow) {

                    _.setSlideClasses(index);
                    _.asNavFor(index);
                    return;

                }

                _.slideHandler(index);

            };

            Slick.prototype.slideHandler = function (index, sync, dontAnimate) {

                var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
                    _ = this, navTarget;

                sync = sync || false;

                if (_.animating === true && _.options.waitForAnimate === true) {
                    return;
                }

                if (_.options.fade === true && _.currentSlide === index) {
                    return;
                }

                if (_.slideCount <= _.options.slidesToShow) {
                    return;
                }

                if (sync === false) {
                    _.asNavFor(index);
                }

                targetSlide = index;
                targetLeft = _.getLeft(targetSlide);
                slideLeft = _.getLeft(_.currentSlide);

                _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;

                if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
                    if (_.options.fade === false) {
                        targetSlide = _.currentSlide;
                        if (dontAnimate !== true) {
                            _.animateSlide(slideLeft, function () {
                                _.postSlide(targetSlide);
                            });
                        } else {
                            _.postSlide(targetSlide);
                        }
                    }
                    return;
                } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
                    if (_.options.fade === false) {
                        targetSlide = _.currentSlide;
                        if (dontAnimate !== true) {
                            _.animateSlide(slideLeft, function () {
                                _.postSlide(targetSlide);
                            });
                        } else {
                            _.postSlide(targetSlide);
                        }
                    }
                    return;
                }

                if (_.options.autoplay) {
                    clearInterval(_.autoPlayTimer);
                }

                if (targetSlide < 0) {
                    if (_.slideCount % _.options.slidesToScroll !== 0) {
                        animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
                    } else {
                        animSlide = _.slideCount + targetSlide;
                    }
                } else if (targetSlide >= _.slideCount) {
                    if (_.slideCount % _.options.slidesToScroll !== 0) {
                        animSlide = 0;
                    } else {
                        animSlide = targetSlide - _.slideCount;
                    }
                } else {
                    animSlide = targetSlide;
                }

                _.animating = true;

                _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);

                oldSlide = _.currentSlide;
                _.currentSlide = animSlide;

                _.setSlideClasses(_.currentSlide);

                if (_.options.asNavFor) {

                    navTarget = _.getNavTarget();
                    navTarget = navTarget.slick('getSlick');

                    if (navTarget.slideCount <= navTarget.options.slidesToShow) {
                        navTarget.setSlideClasses(_.currentSlide);
                    }

                }

                _.updateDots();
                _.updateArrows();

                if (_.options.fade === true) {
                    if (dontAnimate !== true) {

                        _.fadeSlideOut(oldSlide);

                        _.fadeSlide(animSlide, function () {
                            _.postSlide(animSlide);
                        });

                    } else {
                        _.postSlide(animSlide);
                    }
                    _.animateHeight();
                    return;
                }

                if (dontAnimate !== true) {
                    _.animateSlide(targetLeft, function () {
                        _.postSlide(animSlide);
                    });
                } else {
                    _.postSlide(animSlide);
                }

            };

            Slick.prototype.startLoad = function () {

                var _ = this;

                if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {

                    _.$prevArrow.hide();
                    _.$nextArrow.hide();

                }

                if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {

                    _.$dots.hide();

                }

                _.$slider.addClass('slick-loading');

            };

            Slick.prototype.swipeDirection = function () {

                var xDist, yDist, r, swipeAngle, _ = this;

                xDist = _.touchObject.startX - _.touchObject.curX;
                yDist = _.touchObject.startY - _.touchObject.curY;
                r = Math.atan2(yDist, xDist);

                swipeAngle = Math.round(r * 180 / Math.PI);
                if (swipeAngle < 0) {
                    swipeAngle = 360 - Math.abs(swipeAngle);
                }

                if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
                    return (_.options.rtl === false ? 'left' : 'right');
                }
                if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
                    return (_.options.rtl === false ? 'left' : 'right');
                }
                if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
                    return (_.options.rtl === false ? 'right' : 'left');
                }
                if (_.options.verticalSwiping === true) {
                    if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
                        return 'down';
                    } else {
                        return 'up';
                    }
                }

                return 'vertical';

            };

            Slick.prototype.swipeEnd = function (event) {

                var _ = this,
                    slideCount,
                    direction;

                _.dragging = false;
                _.interrupted = false;
                _.shouldClick = (_.touchObject.swipeLength > 10) ? false : true;

                if (_.touchObject.curX === undefined) {
                    return false;
                }

                if (_.touchObject.edgeHit === true) {
                    _.$slider.trigger('edge', [_, _.swipeDirection()]);
                }

                if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {

                    direction = _.swipeDirection();

                    switch (direction) {

                        case 'left':
                        case 'down':

                            slideCount =
                                _.options.swipeToSlide ?
                                    _.checkNavigable(_.currentSlide + _.getSlideCount()) :
                                    _.currentSlide + _.getSlideCount();

                            _.currentDirection = 0;

                            break;

                        case 'right':
                        case 'up':

                            slideCount =
                                _.options.swipeToSlide ?
                                    _.checkNavigable(_.currentSlide - _.getSlideCount()) :
                                    _.currentSlide - _.getSlideCount();

                            _.currentDirection = 1;

                            break;

                        default:


                    }

                    if (direction != 'vertical') {

                        _.slideHandler(slideCount);
                        _.touchObject = {};
                        _.$slider.trigger('swipe', [_, direction]);

                    }

                } else {

                    if (_.touchObject.startX !== _.touchObject.curX) {

                        _.slideHandler(_.currentSlide);
                        _.touchObject = {};

                    }

                }

            };

            Slick.prototype.swipeHandler = function (event) {

                var _ = this;

                if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
                    return;
                } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
                    return;
                }

                _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
                    event.originalEvent.touches.length : 1;

                _.touchObject.minSwipe = _.listWidth / _.options
                    .touchThreshold;

                if (_.options.verticalSwiping === true) {
                    _.touchObject.minSwipe = _.listHeight / _.options
                        .touchThreshold;
                }

                switch (event.data.action) {

                    case 'start':
                        _.swipeStart(event);
                        break;

                    case 'move':
                        _.swipeMove(event);
                        break;

                    case 'end':
                        _.swipeEnd(event);
                        break;

                }

            };

            Slick.prototype.swipeMove = function (event) {

                var _ = this,
                    edgeWasHit = false,
                    curLeft, swipeDirection, swipeLength, positionOffset, touches;

                touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;

                if (!_.dragging || touches && touches.length !== 1) {
                    return false;
                }

                curLeft = _.getLeft(_.currentSlide);

                _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
                _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;

                _.touchObject.swipeLength = Math.round(Math.sqrt(
                    Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));

                if (_.options.verticalSwiping === true) {
                    _.touchObject.swipeLength = Math.round(Math.sqrt(
                        Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
                }

                swipeDirection = _.swipeDirection();

                if (swipeDirection === 'vertical') {
                    return;
                }

                if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
                    event.preventDefault();
                }

                positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
                if (_.options.verticalSwiping === true) {
                    positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
                }


                swipeLength = _.touchObject.swipeLength;

                _.touchObject.edgeHit = false;

                if (_.options.infinite === false) {
                    if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
                        swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
                        _.touchObject.edgeHit = true;
                    }
                }

                if (_.options.vertical === false) {
                    _.swipeLeft = curLeft + swipeLength * positionOffset;
                } else {
                    _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
                }
                if (_.options.verticalSwiping === true) {
                    _.swipeLeft = curLeft + swipeLength * positionOffset;
                }

                if (_.options.fade === true || _.options.touchMove === false) {
                    return false;
                }

                if (_.animating === true) {
                    _.swipeLeft = null;
                    return false;
                }

                _.setCSS(_.swipeLeft);

            };

            Slick.prototype.swipeStart = function (event) {

                var _ = this,
                    touches;

                _.interrupted = true;

                if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
                    _.touchObject = {};
                    return false;
                }

                if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
                    touches = event.originalEvent.touches[0];
                }

                _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
                _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;

                _.dragging = true;

            };

            Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function () {

                var _ = this;

                if (_.$slidesCache !== null) {

                    _.unload();

                    _.$slideTrack.children(this.options.slide).detach();

                    _.$slidesCache.appendTo(_.$slideTrack);

                    _.reinit();

                }

            };

            Slick.prototype.unload = function () {

                var _ = this;

                $('.slick-cloned', _.$slider).remove();

                if (_.$dots) {
                    _.$dots.remove();
                }

                if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
                    _.$prevArrow.remove();
                }

                if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
                    _.$nextArrow.remove();
                }

                _.$slides
                    .removeClass('slick-slide slick-active slick-visible slick-current')
                    .attr('aria-hidden', 'true')
                    .css('width', '');

            };

            Slick.prototype.unslick = function (fromBreakpoint) {

                var _ = this;
                _.$slider.trigger('unslick', [_, fromBreakpoint]);
                _.destroy();

            };

            Slick.prototype.updateArrows = function () {

                var _ = this,
                    centerOffset;

                centerOffset = Math.floor(_.options.slidesToShow / 2);

                if (_.options.arrows === true &&
                    _.slideCount > _.options.slidesToShow &&
                    !_.options.infinite) {

                    _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
                    _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');

                    if (_.currentSlide === 0) {

                        _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
                        _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');

                    } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {

                        _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
                        _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');

                    } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {

                        _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
                        _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');

                    }

                }

            };

            Slick.prototype.updateDots = function () {

                var _ = this;

                if (_.$dots !== null) {

                    _.$dots
                        .find('li')
                        .removeClass('slick-active')
                        .attr('aria-hidden', 'true');

                    _.$dots
                        .find('li')
                        .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))
                        .addClass('slick-active')
                        .attr('aria-hidden', 'false');

                }

            };

            Slick.prototype.visibility = function () {

                var _ = this;

                if (_.options.autoplay) {

                    if (document[_.hidden]) {

                        _.interrupted = true;

                    } else {

                        _.interrupted = false;

                    }

                }

            };

            $.fn.slick = function () {
                var _ = this,
                    opt = arguments[0],
                    args = Array.prototype.slice.call(arguments, 1),
                    l = _.length,
                    i,
                    ret;
                for (i = 0; i < l; i++) {
                    if (typeof opt == 'object' || typeof opt == 'undefined')
                        _[i].slick = new Slick(_[i], opt);
                    else
                        ret = _[i].slick[opt].apply(_[i].slick, args);
                    if (typeof ret != 'undefined') return ret;
                }
                return _;
            };

        }));


        /***/
    }),
/* 48 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        __webpack_require__(101);

        var _header = __webpack_require__(52);

        var header = _interopRequireWildcard(_header);

        var _landingSlide = __webpack_require__(55);

        var landingSlide = _interopRequireWildcard(_landingSlide);

        var _slider = __webpack_require__(18);

        var slider = _interopRequireWildcard(_slider);

        var _hamburgerMenu = __webpack_require__(51);

        var hamburgerMenu = _interopRequireWildcard(_hamburgerMenu);

        var _internationalMap = __webpack_require__(54);

        var internationalMap = _interopRequireWildcard(_internationalMap);

        var _cartsListToggle = __webpack_require__(63);

        var cartsList = _interopRequireWildcard(_cartsListToggle);

        var _inspirationModal = __webpack_require__(11);

        var modal = _interopRequireWildcard(_inspirationModal);

        var _inspirationDetails = __webpack_require__(62);

        var inspirationDetails = _interopRequireWildcard(_inspirationDetails);

        var _footer = __webpack_require__(50);

        var footer = _interopRequireWildcard(_footer);

        var _informationAccordion = __webpack_require__(53);

        var informationAccordion = _interopRequireWildcard(_informationAccordion);

        var _contactMap = __webpack_require__(4);

        var contact = _interopRequireWildcard(_contactMap);

        var _cookieAlert = __webpack_require__(64);

        var cookieAlert = _interopRequireWildcard(_cookieAlert);

        var _select = __webpack_require__(34);

        var select = _interopRequireWildcard(_select);

        var _tabs = __webpack_require__(57);

        var tabs = _interopRequireWildcard(_tabs);

        var _standardPageFooterSubmit = __webpack_require__(66);

        var footerSubmit = _interopRequireWildcard(_standardPageFooterSubmit);

        var _buttonBlack = __webpack_require__(17);

        var buttonBlack = _interopRequireWildcard(_buttonBlack);

        var _loginModal = __webpack_require__(56);

        var loginModal = _interopRequireWildcard(_loginModal);

        var _userProfile = __webpack_require__(67);

        var deleteUserProfileModal = _interopRequireWildcard(_userProfile);

        var _brandList = __webpack_require__(60);

        var brandList = _interopRequireWildcard(_brandList);

        var _formItems = __webpack_require__(59);

        var formValidate = _interopRequireWildcard(_formItems);

        var _timeline = __webpack_require__(58);

        var timeLine = _interopRequireWildcard(_timeline);

        var _benefitCart = __webpack_require__(49);

        var benefitCart = _interopRequireWildcard(_benefitCart);

        var _productDetails = __webpack_require__(65);

        var productDetails = _interopRequireWildcard(_productDetails);

        var _downloads = __webpack_require__(61);

        var downloads = _interopRequireWildcard(_downloads);

        function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

        window.SAPATECH = {};

        var init = function init() {
            cookieAlert.init();
            productDetails.init();
            header.init();
            slider.init();
            hamburgerMenu.init();
            landingSlide.init();
            cartsList.init();
            benefitCart.init();
            internationalMap.init();
            modal.init();
            contact.init();
            informationAccordion.init();
            inspirationDetails.init();
            footer.init();
            select.init();
            tabs.init();
            footerSubmit.init();
            buttonBlack.init();
            loginModal.init();
            deleteUserProfileModal.init();
            brandList.init();
            downloads.init();
            formValidate.init();
            timeLine.init();
        };

        (function () {
            return init();
        })();

        /***/
    }),
/* 49 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _contactMap = __webpack_require__(4);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * init
         */
        function init() {
            var isMobileDevice = /iPhone|iPad|iPod|Android|blackberry|nokia|opera mini|windows mobile|windows phone|iemobile/i.test(navigator.userAgent);

            (0, _jquery2.default)('.benefit-card__content ul').each(function (idx) {
                (0, _contactMap.addCustomScroll)('.details-benefits > div:nth-child(' + (idx + 1) + ') > .benefit-card__content > ul', {
                    suppressScrollX: true,
                    scrollXMarginOffset: 10
                });
            });
            if (!isMobileDevice) {
                (0, _jquery2.default)(window).on('resize', function () {
                    (0, _jquery2.default)('.benefit-card__content ul').each(function (idx) {
                        (0, _contactMap.updateCustomScroll)('.details-benefits > div:nth-child(' + (idx + 1) + ') > .benefit-card__content > ul', {
                            suppressScrollX: true,
                            scrollXMarginOffset: 10
                        });
                    });
                });
            }
        }

        /***/
    }),
/* 50 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Init sticky Button
         */
        function stickyButtonInit() {
            var $window = (0, _jquery2.default)(window);
            var $body = (0, _jquery2.default)('body');
            var $footer = (0, _jquery2.default)('.footer', $body);
            $window.on('load scroll', function () {
                if ($window.scrollTop() + $window.height() > $footer.offset().top) {
                    $footer.addClass('footer--visible');
                } else {
                    $footer.removeClass('footer--visible');
                }
            });
        }

        /**
         * Init footer
         */
        function init() {
            var isMobileDevice = /iPhone|iPad|iPod|Android|blackberry|nokia|opera mini|windows mobile|windows phone|iemobile/i.test(navigator.userAgent);
            var $body = (0, _jquery2.default)('body');
            var $footer = (0, _jquery2.default)('.footer', $body);
            var footerClsSticky = 'footer--stick-bottom';
            var hasScrollbar = function hasScrollbar() {
                return $body.height() > (0, _jquery2.default)(window).height();
            };
            // check one more method updateBodyHeigth in button-black.js
            var loadHandler = function loadHandler() {
                if ($body.hasClass('edit-mode') || (0, _jquery2.default)('.slide').hasClass('slide--full-height')) {
                    return;
                }
                $body.css('height', 'auto');
                $footer.removeClass(footerClsSticky);

                setTimeout(function () {
                    if (!hasScrollbar()) {
                        $footer.addClass(footerClsSticky);
                        $body.css('height', 'auto');
                        $body.css('height', (0, _jquery2.default)(window).height());
                    } else {
                        $body.css('height', 'auto');
                        $body.css('height', (0, _jquery2.default)(window).height());
                    }
                }, 300); // 300 - to recalculate after body height was added
            };
            var resizeHandler = function resizeHandler() {
                if (isMobileDevice) {
                    return false;
                }
                var ie11 = navigator.userAgent.match(/rv:11.0/i);
                var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
                var ieEdge = window.navigator.userAgent.indexOf('Edge/');
                if (ie11 || ieEdge || isFirefox) {
                    setTimeout(function () {
                        $footer.removeClass(footerClsSticky);
                        $body.trigger('click');
                    }, 310);
                }

                loadHandler();
            };

            if ((0, _jquery2.default)('.footer__sticky-button', $footer).length) {
                stickyButtonInit();
            }

            (0, _jquery2.default)(window).on('resize', resizeHandler).on('load', loadHandler);

            // specially for mac-air on scroll bug
            window.addEventListener('orientationchange', function () {
                if (isMobileDevice) {
                    loadHandler();
                    setTimeout(function () {
                        $footer.removeClass(footerClsSticky);
                        $body.trigger('click');
                    }, 200);
                }
            }, false);
        }

        /***/
    }),
/* 51 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var hamburgerButtonCls = '.hamburger-menu__button';
        var hamburgerMenuCls = '.hamburger-menu';
        var hamburgerMenuOpenedClass = 'hamburger-menu--opened';
        var hamburgerButtonCloseClass = 'hamburger-menu__button--close';
        var hamburgerLanguageCls = '.language';
        var hamburgerLanguageActiveClass = 'active';

        /**
         * Toggle hamburger menu popover
         */
        function toggleHamburgerMenu() {
            (0, _jquery2.default)(hamburgerButtonCls).toggleClass(hamburgerButtonCloseClass);
            (0, _jquery2.default)(hamburgerMenuCls).toggleClass(hamburgerMenuOpenedClass);
        }

        /**
         * Toggle hamburger menu popover
         */
        function toggleLanguage(e) {
            if (!(0, _jquery2.default)(e.target).hasClass(hamburgerLanguageActiveClass)) {
                (0, _jquery2.default)(hamburgerLanguageCls).removeClass(hamburgerLanguageActiveClass);
            }
            (0, _jquery2.default)(e.target).addClass(hamburgerLanguageActiveClass);
        }

        /**
         * Toggle modal Popup
         */
        function toggleModalPopup() {
            var $userRole = (0, _jquery2.default)('.js_change_role');
            var $modalWrapper = (0, _jquery2.default)('#modal-starter');
            var $closeBtn = (0, _jquery2.default)('.js_select_role', $modalWrapper);
            var modalOverflow = 'modal-open';

            $userRole.on('click',
                function (e) {
                    if (!e.currentTarget.querySelector("a").href) {
                        e.preventDefault();
                        toggleHamburgerMenu();
                        if ($modalWrapper.length) {
                            (0, _jquery2.default)($modalWrapper).show();
                            (0, _jquery2.default)('body').addClass(modalOverflow);
                        }
                    }
                });

            $closeBtn.on('click', function () {
                (0, _jquery2.default)($modalWrapper).hide();
                (0, _jquery2.default)('body').removeClass(modalOverflow);
            });
        }

        /**
         * Init hamburger menu
         */
        function init() {
            (0, _jquery2.default)(hamburgerButtonCls).on('click', function () {
                toggleHamburgerMenu();
            });

            (0, _jquery2.default)(document).on('click', function (event) {
                if (!(0, _jquery2.default)(event.target).closest(hamburgerMenuCls + ', ' + hamburgerButtonCls).length && (0, _jquery2.default)(hamburgerMenuCls).hasClass(hamburgerMenuOpenedClass)) {
                    toggleHamburgerMenu();
                }
            });

            (0, _jquery2.default)(hamburgerLanguageCls).on('click', function (e) {
                toggleLanguage(e);
            });

            toggleModalPopup();

            (0, _jquery2.default)(window).bind('pageshow', function (event) {
                if (event.originalEvent.persisted) {
                    window.location.reload();
                }
            });
        }

        /***/
    }),
/* 52 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _easyAutocomplete = __webpack_require__(100);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var searchWrapperCls = '.header-search';
        var searchButtonCls = '.header__search-button';
        var searchButtonCloseCls = 'header__search-button--close';
        var searchOpenedCls = 'header-search--opened';

        /**
         * Toggle header scroll class
         */
        function toggleScrollClass() {
            var $header = (0, _jquery2.default)('.header');
            var headerScrollClass = 'header--scrolled';

            if ((0, _jquery2.default)(document).scrollTop() > 30) {
                $header.addClass(headerScrollClass);
                return;
            }

            $header.removeClass(headerScrollClass);
        }

        /**
         * Toggle search popover
         */
        function toggleSearchPopover() {
            var $searchWrapper = (0, _jquery2.default)(searchWrapperCls);

            $searchWrapper.toggleClass(searchOpenedCls);
            (0, _jquery2.default)(searchButtonCls).toggleClass(searchButtonCloseCls);

            if ($searchWrapper.hasClass(searchOpenedCls)) {
                setTimeout(function () {
                    $searchWrapper.find('input[type=search]').focus();
                }, 100);
                return;
            }

            $searchWrapper.find('input[type=search]').val('').blur();
        }

        /**
         * autoComplete
         */
        function autoComplete(suggestionsData) {
            console.info(_easyAutocomplete.EasyAutocomplete);

            var options = {
                data: suggestionsData,
                // url: suggestionsUrl,
                getValue: 'value',
                template: {
                    type: 'links',
                    fields: {
                        link: 'link'
                    }
                },
                list: {
                    maxNumberOfElements: 10,
                    match: {
                        enabled: true
                    }
                }
            };

            (0, _jquery2.default)('#autocomplete').easyAutocomplete(options);
        }
        var entity = /&(?:#x[a-f0-9]+|#[0-9]+|[a-z0-9]+);?/ig;

        /**
         * decodeString
         */
        function decodeString(str) {
            var element = document.createElement('div');
            var str1 = str.replace(entity, function (m) {
                element.innerHTML = m;
                return element.textContent;
            });
            element.remove();

            return str1;
        }

        /**
         * Init header
         */
        function init() {
            var suggestionsUrl = (0, _jquery2.default)('.header-search').attr('data-suggestions-api');
            toggleScrollClass();

            (0, _jquery2.default)(searchButtonCls).on('click', function () {
                if (!(0, _jquery2.default)(searchButtonCls).hasClass(searchButtonCloseCls)) {
                    toggleSearchPopover();
                    _jquery2.default.ajax({
                        url: suggestionsUrl
                    }).done(function (data) {
                        var dataDecode = [];
                        data.forEach(function (item) {
                            if (item.link && item.value) {
                                dataDecode.push({ link: item.link, value: decodeString(item.value) });
                            }
                        });
                        autoComplete(dataDecode);
                        (0, _jquery2.default)('.header-search').attr('data-suggestions-recieved', data);
                    }).fail(function () {
                        console.info('error');
                    });
                }
            });

            (0, _jquery2.default)(window).scroll(function () {
                toggleScrollClass();
            });

            (0, _jquery2.default)(document).on('click', function (event) {
                if (!(0, _jquery2.default)(event.target).closest(searchWrapperCls + ', ' + searchButtonCls).length && (0, _jquery2.default)(searchButtonCls).hasClass(searchButtonCloseCls)) {
                    toggleSearchPopover();
                }
            });
        }

        /***/
    }),
/* 53 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var accordionCls = '.information-accordion';
        var accordionOpenedCls = 'information-accordion--opened';
        var accordionOverviewCls = '.information-accordion--unlock .information-accordion__overview';

        /**
         * Init information accordion
         */
        function init() {
            var $body = (0, _jquery2.default)('body');
            (0, _jquery2.default)(accordionOverviewCls).click(function (event) {
                (0, _jquery2.default)(event.currentTarget).closest(accordionCls).toggleClass(accordionOpenedCls);
                $body.css('height', 'auto');
                setTimeout(function () {
                    $body.css('height', (0, _jquery2.default)(document).height());
                }, 210);
            });
        }

        /***/
    }),
/* 54 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Init international map
         */
        function init() {
            var pseudoSelectCls = '.international-map__pseudo-select';
            var regionsListCls = '.international-map__regions';
            var regionCountryCls = '.region__country';

            var regionsListOpened = 'international-map__regions--opened';

            var $pseudoSelect = (0, _jquery2.default)(pseudoSelectCls);
            var $regionsList = (0, _jquery2.default)(regionsListCls);

            $pseudoSelect.on('click', function () {
                $regionsList.addClass(regionsListOpened);
            });

            (0, _jquery2.default)(document).on('click', function (event) {
                if (!(0, _jquery2.default)(event.target).closest(pseudoSelectCls + ', ' + regionsListCls).length || (0, _jquery2.default)(event.target).is(regionCountryCls)) {
                    $regionsList.removeClass(regionsListOpened);
                }
            });
        }

        /***/
    }),
/* 55 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _contactMap = __webpack_require__(4);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * init
         */
        function init() {
            var slider = (0, _jquery2.default)('.slide--full-height.worldmap');
            var $header = (0, _jquery2.default)('.header');
            var $internationalMap = (0, _jquery2.default)('.international-map');
            if (slider.length) {
                (0, _jquery2.default)('.landing-slide__link', slider).on('click', function (e) {
                    if ((0, _jquery2.default)(e.target).attr('href') === '') {
                        e.preventDefault();
                        // scroll to list
                        (0, _contactMap.scrollTo)($internationalMap, $header);
                    }
                });
            }
        }

        /***/
    }),
/* 56 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _buttonBlack = __webpack_require__(17);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var modalOverflow = 'modal-open show-overflow';
        var showBackElements = [];
        var $body = (0, _jquery2.default)('body');

        /**
         * check if modal opened in mobile screen
         */
        function isMobileModal() {
            var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
            var elToShow = ['#modal-login', '.hamburger-menu', '.header', '.footer'];
            var $siblingsAll = (0, _jquery2.default)('body').children().nextAll(':visible').get();

            if (browserWidth < 767 && (0, _jquery2.default)('body').hasClass(modalOverflow)) {
                // open modal
                $siblingsAll.forEach(function (sibling) {
                    (0, _jquery2.default)(sibling).hide();
                    showBackElements.push(sibling);
                });
                elToShow.forEach(function (whiteList) {
                    (0, _jquery2.default)(whiteList).show();
                });
            } else {
                // close modal
                showBackElements.forEach(function (element) {
                    (0, _jquery2.default)(element).show();
                });
                showBackElements.length = 0;
            }
        }

        /**
         * Toggle modal Popup
         */
        function toggleModalPopup() {
            var $userLogin = (0, _jquery2.default)('.js_user_login');
            var $modalWrapper = (0, _jquery2.default)('#modal-login');
            var $closeBtn = (0, _jquery2.default)('.js_close_user_login', $modalWrapper);
            var $headerBtnBox = (0, _jquery2.default)('.header__login-button-box');
            var $headerBtnBoxOffCls = 'header__login-button-box--hover-off';
            var modalOverflow = 'modal-open show-overflow';

            $userLogin.on('click', function (e) {
                e.preventDefault();

                var redirect = window.location.href;
                var dataurl = $(e.currentTarget).data("login");
                if (dataurl) {
                    debugger;
                    redirect = dataurl;
                }

                window.location.href = "/login?redirect=" + redirect;
                return;

                if ($modalWrapper.length) {
                    (0, _jquery2.default)($modalWrapper).show();
                    (0, _jquery2.default)('body').addClass(modalOverflow);
                    $headerBtnBox.addClass($headerBtnBoxOffCls);
                }
                isMobileModal();
                (0, _buttonBlack.updateBodyHeigth)($body, (0, _jquery2.default)('.footer', $body), 'footer--stick-bottom');
            });

            $closeBtn.on('click', function () {
                (0, _jquery2.default)('body').removeClass(modalOverflow);
                $headerBtnBox.removeClass($headerBtnBoxOffCls);
                isMobileModal();
                (0, _jquery2.default)($modalWrapper).hide();
                (0, _jquery2.default)(window).trigger('resize');
                (0, _buttonBlack.updateBodyHeigth)($body, (0, _jquery2.default)('.footer', $body), 'footer--stick-bottom');
            });

            // Store the window width for iOS bug
            var windowWidth = (0, _jquery2.default)(window).width();
            (0, _jquery2.default)(window).on('resize', function () {
                var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
                if ((0, _jquery2.default)(window).width() !== windowWidth) {
                    if (browserWidth < 767 && (0, _jquery2.default)('body').hasClass(modalOverflow) && (0, _jquery2.default)('#modal-login').css('display') === 'block') {
                        $userLogin.trigger('click');
                    }
                }
            });

            // When the user clicks anywhere outside of the modal, close it
            (0, _jquery2.default)(window).on('click', function (event) {
                if (event.target === $modalWrapper.get(0)) {
                    $modalWrapper.hide();
                    (0, _jquery2.default)('body').removeClass(modalOverflow);
                    $headerBtnBox.removeClass($headerBtnBoxOffCls);
                }
                (0, _buttonBlack.updateBodyHeigth)($body, (0, _jquery2.default)('.footer', $body), 'footer--stick-bottom');
            });
        }

        function toggleModalPopupNewsletter() {
            //var $userLogin1 = (0, _jquery2.default)('.js_user_login_newsletter');
            var $modalWrapper1 = (0, _jquery2.default)('#modal-newsletter');
            var $closeBtn1 = (0, _jquery2.default)('.js_close_newsletter', $modalWrapper1);
            var $headerBtnBox = (0, _jquery2.default)('.header__login-button-box');
            var $headerBtnBoxOffCls = 'header__login-button-box--hover-off';
            var modalOverflow = 'modal-open show-overflow';


            //$userLogin1.on('click', function (e) {
            //    e.preventDefault();
            //    if ($modalWrapper1.length) {
            //        (0, _jquery2.default)($modalWrapper1).show();
            //        (0, _jquery2.default)('body').addClass(modalOverflow);
            //        $headerBtnBox.addClass($headerBtnBoxOffCls);
            //    }
            //    (0, _buttonBlack.updateBodyHeigth)($body, (0, _jquery2.default)('.footer', $body), 'footer--stick-bottom');
            //});

            $closeBtn1.on('click', function () {
                (0, _jquery2.default)('body').removeClass(modalOverflow);
                $headerBtnBox.removeClass($headerBtnBoxOffCls);
                //isMobileModal();
                (0, _jquery2.default)($modalWrapper1).hide();
                (0, _jquery2.default)(window).trigger('resize');
                (0, _buttonBlack.updateBodyHeigth)($body, (0, _jquery2.default)('.footer', $body), 'footer--stick-bottom');
            });

            // Store the window width for iOS bug
            var windowWidth = (0, _jquery2.default)(window).width();
            (0, _jquery2.default)(window).on('resize', function () {
                var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
                if ((0, _jquery2.default)(window).width() !== windowWidth) {
                    if (browserWidth < 767 && (0, _jquery2.default)('body').hasClass(modalOverflow) && (0, _jquery2.default)('#modal-newsletter').css('display') === 'block') {
                        $userLogin1.trigger('click');
                    }
                }
            });

            // When the user clicks anywhere outside of the modal, close it
            (0, _jquery2.default)(window).on('click', function (event) {
                if (event.target === $modalWrapper1.get(0)) {
                    $modalWrapper1.hide();
                    (0, _jquery2.default)('body').removeClass(modalOverflow);
                    $headerBtnBox.removeClass($headerBtnBoxOffCls);
                }
                (0, _buttonBlack.updateBodyHeigth)($body, (0, _jquery2.default)('.footer', $body), 'footer--stick-bottom');
            });
        }
        /**
         * Init hamburger menu
         */

        function init() {
            toggleModalPopup();
            toggleModalPopupNewsletter();
        }


        /***/
    }),
/* 57 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _contactMap = __webpack_require__(4);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         *
         * @param $tabs - wrapper
         */
        function scrollToSelectedTab($linkTabs) {
            var $activeLi = (0, _jquery2.default)('.link-tabs__tab--active', $linkTabs);
            $linkTabs.animate({ scrollLeft: $activeLi.position().left }, 750);
        }

        /**
         * trigger click for Checked Tab (IE bug only)
         */
        function triggerCheckedTab($tabInput) {
            $tabInput.each(function (ii, item) {
                if ((0, _jquery2.default)(item).is(':checked') || (0, _jquery2.default)(item).attr('checked')) {
                    (0, _jquery2.default)(item).trigger('click');
                }
            });
        }

        /**
         * Change reset button appearance in product category form
         */
        function init() {
            var $tabs = (0, _jquery2.default)('.tabs');
            var $tabInput = (0, _jquery2.default)('input', $tabs);
            var $tabContent = (0, _jquery2.default)('.tab__content', $tabs);
            var $linkTabs = (0, _jquery2.default)('.link-tabs');
            var scrollToActiveCls = 'js_scroll-to-active';
            var $documents = (0, _jquery2.default)('.details-overview__documents .document', $tabs);
            var totalWidth = 0;
            var checkCustomScroll = function checkCustomScroll() {
                var isProductDetailsPage = (0, _jquery2.default)('.details-wrapper .details-overview .tabs').length;

                if (!isProductDetailsPage) {
                    return;
                }
                var innerPadding = 30; // get from css;
                if ($tabContent.hasClass('js_custom-scroll-x') && totalWidth + ($documents.length - 1) * innerPadding > (0, _jquery2.default)('.tab__content.js_custom-scroll-x').width()) {
                    (0, _contactMap.addCustomScroll)('.js_custom-scroll-x');
                } else {
                    (0, _contactMap.destroyCustomScroll)('.js_custom-scroll-x');
                }
            };

            if (!$tabs.length && !$linkTabs.length) {
                return;
            }
            $documents.each(function () {
                totalWidth += (0, _jquery2.default)(this).width();
            });

            (0, _contactMap.addCustomScroll)('.js_custom-scroll-x');

            if ($linkTabs.hasClass(scrollToActiveCls)) {
                scrollToSelectedTab($linkTabs);
            }

            $tabInput.on('change', function () {
                (0, _contactMap.updateCustomScroll)('.js_custom-scroll-x');
                checkCustomScroll();
            });

            (0, _jquery2.default)(window).on('resize', function () {
                checkCustomScroll();
            }).on('load', function () {
                // IE edge fix
                checkCustomScroll();
                triggerCheckedTab($tabInput);
            });
        }

        /***/
    }),
/* 58 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _slickCarousel = __webpack_require__(47);

        var _slickCarousel2 = _interopRequireDefault(_slickCarousel);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var $slider = (0, _jquery2.default)('.timeline');
        var sliderInit = function sliderInit() {
            var $parent = $slider.closest('.generic-block');
            if ((0, _jquery2.default)('.edit-mode, .preview-mode').length) {
                $parent.css('max-width', $parent.width());
                if ((0, _jquery2.default)('.timeline').hasClass('slick-initialized')) {
                    (0, _jquery2.default)('.timeline').slick('destroy');
                }
            }

            $slider.slick({
                speed: 400,
                infinite: !1,
                slidesToShow: 6,
                slidesToScroll: 1,
                cssEase: 'ease-in-out',
                responsive: [{
                    breakpoint: 1440,
                    settings: {
                        slidesToShow: 5
                    }
                }, {
                    breakpoint: 1200,
                    settings: {
                        slidesToShow: 4
                    }
                }, {
                    breakpoint: 1125,
                    settings: {
                        slidesToShow: 3
                    }
                }, {
                    breakpoint: 820,
                    settings: {
                        slidesToShow: 2
                    }
                }, {
                    breakpoint: 767,
                    settings: {
                        slidesToShow: 3
                    }
                }, {
                    breakpoint: 500,
                    settings: {
                        slidesToShow: 2
                    }
                }, {
                    breakpoint: 400,
                    settings: {
                        slidesToShow: 1
                    }
                }]
            });
        };

        /**
         * Init slider
         */
        function init() {












            var ie11 = navigator.userAgent.match(/rv:11.0/i);
            var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
            if (!_slickCarousel2.default || !$slider || !$slider.length) {
                return;
            }
            if (ie11 || isFirefox) {
                (0, _jquery2.default)('body').addClass('ave-ie11-ff');
            }
            sliderInit();
            (0, _jquery2.default)(window).on('resize', function () {
                var $parent = $slider.closest('.generic-block');
                if ((0, _jquery2.default)('.edit-mode, .preview-mode').length) {
                    $parent.css('max-width', $parent.width());
                    if ((0, _jquery2.default)('.timeline').hasClass('slick-initialized')) {
                        (0, _jquery2.default)('.timeline').slick('destroy');
                        $slider.slick({
                            speed: 400,
                            infinite: !1,
                            slidesToShow: 6,
                            slidesToScroll: 1,
                            cssEase: 'ease-in-out',
                            responsive: [{
                                breakpoint: 1440,
                                settings: {
                                    slidesToShow: 5
                                }
                            }, {
                                breakpoint: 1200,
                                settings: {
                                    slidesToShow: 4
                                }
                            }, {
                                breakpoint: 1125,
                                settings: {
                                    slidesToShow: 3
                                }
                            }, {
                                breakpoint: 820,
                                settings: {
                                    slidesToShow: 2
                                }
                            }, {
                                breakpoint: 767,
                                settings: {
                                    slidesToShow: 3
                                }
                            }, {
                                breakpoint: 500,
                                settings: {
                                    slidesToShow: 2
                                }
                            }, {
                                breakpoint: 400,
                                settings: {
                                    slidesToShow: 1
                                }
                            }]
                        });
                    }
                }
            });
        }

        /***/
    }),
/* 59 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * form-items validate
         */
        function init() {
            var $form = (0, _jquery2.default)('.form-elements-wrap');
            var ie11 = navigator.userAgent.match(/rv:11.0/i);
            var calcIntent = function calcIntent(arraySelector, clsName) {
                var array = (0, _jquery2.default)('.form-item', clsName);
                for (var ii = 0; ii < array.length; ii++) {
                    (0, _jquery2.default)(array[ii]).addClass('form-item--intent-label');
                }
            };

            if (!$form.length) {
                return;
            }
            if (ie11) {
                (0, _jquery2.default)('body').addClass('ave-ie11');
            }

            (0, _jquery2.default)(window).on('load', function () {

                var arrToRecalc = (0, _jquery2.default)('.item-inner > label:not(.hide)', $form).closest('.row');
                for (var ii = 0; ii < arrToRecalc.length; ii++) {
                    (0, _jquery2.default)(arrToRecalc[ii]).addClass('js_calculateLabel-' + ii);
                    calcIntent(arrToRecalc[ii], '.js_calculateLabel-' + ii);
                }
            });
        }

        /***/
    }),
/* 60 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _slider = __webpack_require__(18);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Init
         */
        function init() {
            var $brandCard = (0, _jquery2.default)('.brand-card');
            if (!$brandCard.length) {
                return;
            }
            (0, _slider.setBgImgForIe)($brandCard);
        }

        /***/
    }),
/* 61 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Check that element is visible
         * @param partial
         * @returns {boolean}
         */
        _jquery2.default.fn.visible = function (partial) {

            var $t = (0, _jquery2.default)(this);
            var $w = (0, _jquery2.default)(window);
            var _top = $t.offset().top;
            var _bottom = _top + $t.height();
            var compareTop = partial === true ? _bottom : _top;
            var compareBottom = partial === true ? _top : _bottom;
            var viewTop = $w.scrollTop();
            var viewBottom = viewTop + $w.height();

            return compareBottom <= viewBottom && compareTop >= viewTop;
        };

        /**
         * Init Inspiration
         */
        function init() {
            var $downloadCategory = (0, _jquery2.default)('.download-category-section');
            var win = (0, _jquery2.default)(window);
            var showVisibleImg = function showVisibleImg($downloadCategory, isScroll) {
                $downloadCategory.each(function (i, item) {
                    var el = (0, _jquery2.default)(item);
                    var comeInCls = 'come-in';
                    var updateSrc = function updateSrc(el) {
                        var originalSrcAttr = 'originalsrc';
                        (0, _jquery2.default)('img', el).each(function () {
                            var img = (0, _jquery2.default)(this);
                            img.attr('src', img.attr(originalSrcAttr)); // trigger the image load
                            img.removeAttr(originalSrcAttr); // so we only process this image once
                        });
                    };

                    if (isScroll) {
                        if (el.visible(true)) {
                            el.addClass(comeInCls);
                            updateSrc(el);
                        } else {
                            el.removeClass(comeInCls);
                        }
                    } else if (el.visible(true)) {
                        el.addClass('already-visible');
                        updateSrc(el);
                    }
                });
            };

            if ($downloadCategory.length) {
                showVisibleImg($downloadCategory);

                // win.scroll(function() {
                //   showVisible($downloadCategory, true);
                // });
                win.get(0).addEventListener('scroll', function () {
                    showVisibleImg($downloadCategory, true);
                }, { passive: false });
            }
            window.SAPATECH.showVisibleImg = showVisibleImg;
        }

        /***/
    }),
/* 62 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _contactMap = __webpack_require__(4);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * init
         */
        function init() {
            (0, _jquery2.default)(window).on('load', function () {
                (0, _contactMap.addCustomScroll)('.modal-item-info');
            });
            (0, _jquery2.default)(window).on('load resize', function () {
                (0, _contactMap.updateCustomScroll)('.modal-item-info');
            });
        }

        /***/
    }),
/* 63 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _mapServiceMarkers = __webpack_require__(33);

        var _inspirationModal = __webpack_require__(11);

        var _contactMap = __webpack_require__(4);

        var _lineClamp = __webpack_require__(45);

        var _lineClamp2 = _interopRequireDefault(_lineClamp);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        var host = window.location.host;
        var localhost = /(localhost:3000|127\.0\.0\.1|technal-professional.sapa-001.projects.epam.com)+/ig;

        /**
         * drawGrid
         */
        var drawGrid = function drawGrid() {
            var siteUrl = function siteUrl() {
                return localhost.test(host) ? 'https://technal-professional.sapa-001.projects.epam.com' : '';
            };
            var cartsData = function cartsData() {
                var normalizedObj = {};
                (0, _inspirationModal.getMapData)('#projects', 'projects').forEach(function (item) {
                    normalizedObj[item.Id] = item;
                });
                return normalizedObj;
            };
            var addCart = function addCart(obj, wrapper) {
                var li = [];
                (0, _jquery2.default)(wrapper).empty();
                for (var _item in obj) {
                    if (Object.prototype.hasOwnProperty.call(obj, _item)) {
                        li.push('\n          <div class="project-card" id="' + obj[_item].Id + '">\n            <img src="' + siteUrl() + obj[_item].TeaserImage.Url + '" alt="' + obj[_item].Name + '" class="project-card__image" />\n            <div class="project-card__corner"></div>\n            <div class="project-card__overlay"></div>\n            <div class="project-card__text">\n              <h3 class="project-card__title project-card__title--name desktop-only">' + obj[_item].Name + '</h3>\n              <div class="project-card__title project-card__title--country desktop-only">' + obj[_item].Country + '</div>\n              <h3 class="project-card__title project-card__title--name mob-only js_add-dots">\n                ' + obj[_item].Name + ' ' + (obj[_item].Country ? '/ ' + obj[_item].Country : '') + ' \n              </h3>\n              \n              <div class="project-card__title project-card__title--creator">' + obj[_item].Architect + '</div>              \n            </div>\n            <a href="#" class="project-card__link"></a>\n          </div>\n        ');
                    }
                }
                (0, _jquery2.default)(wrapper).append(li.join(''));
            };
            var item = cartsData();

            addCart(item, '.projects-list');
        };

        var sliderLocationListener = function sliderLocationListener(map) {
            var $locationBtn = (0, _jquery2.default)('.js_slider-location');
            $locationBtn.on('click', function (e) {
                var locationData = (0, _jquery2.default)(e.target).attr('data-location');
                var mapCenterCard = {
                    lat: parseFloat(locationData.split(',')[0], 10),
                    lng: parseFloat(locationData.split(',')[1], 10)
                };
                e.preventDefault();
                (0, _jquery2.default)('.js_close', '#modal-item-info').trigger('click');
                (0, _jquery2.default)('.map-button', '.inspiration-filter').trigger('click');

                if (map) {
                    map.setCenter(mapCenterCard);
                    map.setZoom(11);
                    // scroll to map
                    (0, _contactMap.scrollTo)((0, _jquery2.default)('#google-map'), (0, _jquery2.default)('.header'));
                }
            });
        };

        /**
         * get url param by name
         */
        _jquery2.default.urlParam = function (name) {
            var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(window.location.href);
            if (!results) {
                return 0;
            }
            return results[1] || 0;
        };

        /**
         * pageLoad
         */
        function checkQuryParam(map) {
            (0, _jquery2.default)(document).ready(function () {
                var cartId = _jquery2.default.urlParam('mapId');
                var listId = _jquery2.default.urlParam('listId');
                var cartsData = function cartsData() {
                    var normalizedObj = {};
                    (0, _inspirationModal.getMapData)('#projects', 'projects').forEach(function (item) {
                        normalizedObj[item.Id] = item;
                    });
                    return normalizedObj;
                };
                var item = cartsData();

                if (cartId) {
                    (0, _jquery2.default)('.map-button', '.inspiration-filter').trigger('click');
                    map.panTo({
                        lat: parseFloat(item[cartId].Location.split(',')[0], 10),
                        lng: parseFloat(item[cartId].Location.split(',')[1], 10)
                    });
                    map.setZoom(11);
                }
                if (listId) {
                    (0, _inspirationModal.projectsCardListenr)(listId, 'modal-open show-overflow');
                }
            });
        }

        /**
         * clamp Multyline Dots
         * @param elArray - {array}
         * @param maxLineNumber - {number}
         */
        function clampMultylineDots(elArray, maxLineNumber) {
            var ie11 = window.navigator.userAgent.match(/rv:11.0/i);
            var isFirefox = window.navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
            var ieEdge = window.navigator.userAgent.indexOf('Edge/');
            var clampCls = 'clamp-two-line';
            var originalText = [];

            if (!ie11 && !isFirefox && ieEdge === -1) {
                elArray.addClass(clampCls);
                return; // happy end
            }

            // all hell broke loose: user in IE or ff
            if (elArray.length) {
                var resizeHandle = function resizeHandle() {
                    elArray.each(function (idx, item) {
                        (0, _jquery2.default)(item).text(originalText[idx]);
                        if (ie11) {
                            // console.log('resizeHandle', item);
                            (0, _lineClamp2.default)(item, { lineCount: 3 });
                        } else {
                            (0, _lineClamp2.default)(item, { lineCount: maxLineNumber });
                        }
                    });
                };

                elArray.each(function (idx, item) {
                    originalText.push((0, _jquery2.default)(item).text());
                    (0, _jquery2.default)(item).text('');
                    (0, _jquery2.default)(item).text(originalText[idx]);
                    if (ie11) {
                        // console.log('add lineClamp 3');
                        (0, _lineClamp2.default)(item, { lineCount: 3 });
                    } else {
                        (0, _lineClamp2.default)(item, { lineCount: maxLineNumber });
                    }
                });

                (0, _jquery2.default)(window).on('resize', resizeHandle);

                // check if font was loaded
                var numberCount1 = 2;
                var interval1 = setInterval(function () {
                    numberCount1--;
                    if (numberCount1 === 0) {
                        // webfont is loaded and applied!
                        // console.log('clearInterval');
                        clearInterval(interval1);
                    }
                    (0, _jquery2.default)(window).trigger('resize');
                }, 200);
            }
        }

        /**
         * Init Inspiration
         */
        function init() {
            var $aCartsList = (0, _jquery2.default)('.inspiration-carts-list'),
                $gridButton = (0, _jquery2.default)('.grid-button'),
                $gridWrapper = (0, _jquery2.default)('.projects-list', $aCartsList),
                $mapButton = (0, _jquery2.default)('.map-button', '.inspiration-filter'),
                $mapWrapper = (0, _jquery2.default)('.map', $aCartsList);
            var closeBtnCls = '.js_close';
            var map = {};
            var mapCenter = (0, _inspirationModal.getMapData)('#projects', 'mapcenter') ? (0, _inspirationModal.getMapData)('#projects', 'mapcenter').split(',') : '40,-3'.split(',');
            var mapKey = (0, _jquery2.default)('#google-map', $mapWrapper).data('map-api-key') ? (0, _jquery2.default)('#google-map', $mapWrapper).data('map-api-key') : 'AIzaSyAu_QxEBO0D_g5VSH-fQOQQ2x0MYF6OjZY';
            var mapRefresh = function mapRefresh(_mapCenter) {
                if (typeof google !== 'undefined') {
                    window.google.maps.event.trigger(map, 'resize');
                    if (_mapCenter[0] && _mapCenter[1]) {
                        map.setCenter(new window.google.maps.LatLng({ lat: parseFloat(_mapCenter[0]), lng: parseFloat(_mapCenter[1]) }));
                    } else {
                        map.setCenter(new window.google.maps.LatLng({ lat: parseFloat(mapCenter[0]), lng: parseFloat(mapCenter[1]) }));
                    }
                }
            };
            var showMap = function showMap($mapWrapper) {
                $mapButton.addClass('active');
                $gridButton.removeClass('active');

                $gridWrapper.hide();
                $mapWrapper.addClass('show');
                mapRefresh(mapCenter);
            };
            var markersData = [];

            window.SAPATECH.clampMultylineDots = clampMultylineDots;
            window.SAPATECH.GLOBALGOOGLEMAP_INSPIRATION = function (markersData, center) {
                (0, _mapServiceMarkers.initMap)(mapKey, markersData).then(function (mapObj) {
                    map = mapObj;
                    mapRefresh(center);
                    sliderLocationListener(map);
                });
            };

            if ((0, _jquery2.default)('.projects-list').length && (0, _inspirationModal.getMapData)('#projects', 'projects')) {
                if (localhost.test(host)) {
                    drawGrid();
                    (0, _inspirationModal.getMapData)('#projects', 'projects').forEach(function (item) {
                        if (item && item.Location) {
                            if (parseFloat(item.Location.split(',')[0], 10) || parseFloat(item.Location.split(',')[1], 10)) {
                                markersData.push({
                                    'id': item.Id,
                                    'location': {
                                        'lat': parseFloat(item.Location.split(',')[0], 10),
                                        'lon': parseFloat(item.Location.split(',')[1], 10)
                                    },
                                    'label': item.Name,
                                    'country': item.Country,
                                    'creator': item.Architect,
                                    'description': 'description from cart 1'
                                });
                            }
                        }
                    });
                }
            } else {
                return;
            }

            /* GoogleMapsLoader */
            if ($mapWrapper.length) {
                (0, _mapServiceMarkers.initMap)(mapKey, markersData, mapCenter).then(function (mapObj) {
                    map = mapObj;
                    mapRefresh(mapCenter);
                    sliderLocationListener(map);

                    setTimeout(function () {
                        // setTimeout - to improve UX
                        if (_jquery2.default.urlParam('mapId') || _jquery2.default.urlParam('listId')) {
                            checkQuryParam(map);
                        }
                    }, 1000);
                });
            }

            $mapButton.on('click', function () {
                showMap($mapWrapper);
                (0, _jquery2.default)('.pager-wrapper').hide();
            });

            $gridButton.on('click', function () {
                $mapButton.removeClass('active');
                $gridButton.addClass('active');

                $gridWrapper.show();
                $mapWrapper.removeClass('show');
                (0, _jquery2.default)('.pager-wrapper').show();
            });

            // show inspiration map in mobile if tooltip modal was closed
            // ignore for grid view
            (0, _jquery2.default)(document).on('click', closeBtnCls, function () {
                var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
                if (browserWidth < 767 && (0, _jquery2.default)('.button-group .map-button').hasClass('active')) {
                    $mapWrapper.addClass('show');
                    setTimeout(function () {
                        mapRefresh(mapCenter);
                    }, 1);
                }
            });

            clampMultylineDots((0, _jquery2.default)('.js_add-dots', 'body .content-wrapper .projects-list .project-card'), 2);
        }

        /***/
    }),
/* 64 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _inspirationModal = __webpack_require__(11);

        var _buttonBlack = __webpack_require__(17);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Toggle form popup
         */
        function toggleListener() {
            var $body = (0, _jquery2.default)('body');
            var $toggleBox = (0, _jquery2.default)('.cookie-alert-wrapper', $body);
            var $buttonOk = (0, _jquery2.default)('.button-transparent', $toggleBox);
            var $toggleBoxOpenClass = 'cookie-alert-wrapper--opened';
            var clearStyles = function clearStyles() {
                (0, _jquery2.default)('.cookie-alert-wrapper ~ .header').css({ 'top': 0 });
                (0, _jquery2.default)('.cookie-alert-wrapper ~ .hamburger-menu').css({ 'top': 0 });
                (0, _jquery2.default)('.cookie-alert-wrapper ~ .hamburger-menu .hamburger-menu__button').removeAttr('style');
                (0, _jquery2.default)('.cookie-alert-wrapper ~ .slider__landing-regional').css({ 'paddingTop': 0 });
                (0, _jquery2.default)('.cookie-alert-wrapper ~ .wrapper .wrapper__content').removeAttr('style');
            };

            $buttonOk.on('click', function () {
                (0, _inspirationModal.toggler)($toggleBox, $toggleBoxOpenClass);
                clearStyles();
                (0, _buttonBlack.updateBodyHeigth)($body, (0, _jquery2.default)('.footer', $body), 'footer--stick-bottom');
            });
        }

        /**
         * recalcHeight
         */
        function recalcHeight() {
            var $toggleBox = (0, _jquery2.default)('.cookie-alert-wrapper');
            var browserWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
            var $toggleBoxOpenClass = 'cookie-alert-wrapper--opened';
            var $toggleBoxHeight = browserWidth < 767 ? $toggleBox.get(0).offsetHeight : $toggleBox.get(0).offsetHeight;

            // need to refactor
            if ($toggleBox.hasClass($toggleBoxOpenClass)) {
                (0, _jquery2.default)('.cookie-alert-wrapper--opened ~ .header').css({ 'top': $toggleBoxHeight });
                (0, _jquery2.default)('.cookie-alert-wrapper--opened ~ .hamburger-menu').css({ 'top': $toggleBoxHeight });
                (0, _jquery2.default)('.cookie-alert-wrapper--opened ~ .hamburger-menu .hamburger-menu__button').css({ 'top': $toggleBoxHeight + 29 });
                (0, _jquery2.default)('.cookie-alert-wrapper--opened ~ .slider__landing-regional').css({ 'paddingTop': $toggleBoxHeight });
                (0, _jquery2.default)('.cookie-alert-wrapper--opened ~ .wrapper .wrapper__content').css({ 'paddingTop': $toggleBoxHeight + 160 });
            }
        }

        /**
         * Init Inspiration
         */
        function init() {
            (0, _jquery2.default)('html,body').scrollTop(0);
            toggleListener();
            if ((0, _jquery2.default)('.cookie-alert-wrapper').length) {
                recalcHeight();
                (0, _jquery2.default)(window).on('resize', recalcHeight);
            }
        }

        /***/
    }),
/* 65 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        var _lineClamp = __webpack_require__(45);

        var _lineClamp2 = _interopRequireDefault(_lineClamp);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Init footer
         */
        function init() {
            var el = (0, _jquery2.default)('h2.details-overview__title');
            var pdTitle = el.text();
            var hiddnEl = (0, _jquery2.default)('<div id="main-title-original">' + pdTitle + '</div>');
            var titlePrimary = (0, _jquery2.default)('.title-primary', '.product-category-top');

            if (titlePrimary.length) {
                // console.log('titlePrimary found', $('.title-primary', '.product-category-top'));
                var ie11 = navigator.userAgent.match(/rv:11.0/i);
                var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
                var ieEdge = window.navigator.userAgent.indexOf('Edge/');
                var el1 = titlePrimary;
                var pdTitle1 = el1.text();
                var hiddnEl1 = (0, _jquery2.default)('<div id="main-title-original">' + pdTitle1 + '</div>');
                var resize1 = function resize1() {
                    el1.text(hiddnEl1.text());
                    if (ie11 || isFirefox || ieEdge !== -1) {
                        (0, _lineClamp2.default)(el1[0], { lineCount: 4 });
                    } else {
                        titlePrimary.addClass('title-primary--clamp');
                    }
                };
                el1.text('');
                el1.text(hiddnEl1.text());

                if (ie11 || isFirefox || ieEdge !== -1) {
                    (0, _lineClamp2.default)(el1[0], { lineCount: 4 });
                } else {
                    titlePrimary.addClass('title-primary--clamp');
                }

                (0, _jquery2.default)(window).on('resize', resize1);

                var numberCount = 4;
                var headerSearch = (0, _jquery2.default)('header-search');
                var interval1 = setInterval(function () {
                    numberCount--;
                    if (numberCount === 0 || headerSearch.hasClass('header-search--opened')) {
                        // webfont is loaded and applied!
                        clearInterval(interval1);
                    }
                    (0, _jquery2.default)(window).trigger('click');
                    (0, _jquery2.default)('.header-search__input').focus();
                }, 500);
            }
            if (!pdTitle) {
                return;
            }
            el.text('');
            el.text(hiddnEl.text());

            (0, _lineClamp2.default)(el[0], { lineCount: 2 });

            (0, _jquery2.default)(window).on('resize', function () {
                el.text(hiddnEl.text());
                (0, _lineClamp2.default)(el[0], { lineCount: 2 });
            });
        }

        /***/
    }),
/* 66 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * init
         */
        function init() {
            // init only for standard-page-footer-submit
            if ((0, _jquery2.default)('.footer .footer__subscribe .success-message').length) {
                var $submit = (0, _jquery2.default)('.subscribe-form__submit');
                var $toggleBox = (0, _jquery2.default)('.footer__subscribe');
                var $toggleBoxOpenClass = 'footer__subscribe--success';

                $submit.on('click', function () {
                    $toggleBox.toggleClass($toggleBoxOpenClass);
                });
            }
        }

        /***/
    }),
/* 67 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.init = init;

        var _jquery = __webpack_require__(0);

        var _jquery2 = _interopRequireDefault(_jquery);

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

        /**
         * Toggle modal Popup
         */
        function toggleModalPopup() {
            var $body = (0, _jquery2.default)('body');
            var $userRole = (0, _jquery2.default)('.js_profile_delete');
            var $modalWrapper = (0, _jquery2.default)('#modal-profile-delete');
            var $closeBtn = (0, _jquery2.default)('button', $modalWrapper);
            var modalOverflow = 'modal-open';

            if (!$modalWrapper.length) {
                return;
            }

            $userRole.on('click', function (e) {
                e.preventDefault();
                if ($modalWrapper.length) {
                    (0, _jquery2.default)($modalWrapper).show();
                    $body.addClass(modalOverflow);
                }
            });

            $closeBtn.on('click', function () {
                (0, _jquery2.default)($modalWrapper).hide();
                $body.removeClass(modalOverflow);
            });
        }

        /**
         * Init
         */
        function init() {
            toggleModalPopup();
        }

        /***/
    }),
/* 68 */
/***/ (function (module, exports, __webpack_require__) {

        __webpack_require__(96);
        __webpack_require__(98);
        __webpack_require__(99);
        __webpack_require__(97);
        module.exports = __webpack_require__(12).Promise;

        /***/
    }),
/* 69 */
/***/ (function (module, exports, __webpack_require__) {

        // 22.1.3.31 Array.prototype[@@unscopables]
        var UNSCOPABLES = __webpack_require__(1)('unscopables')
            , ArrayProto = Array.prototype;
        if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(10)(ArrayProto, UNSCOPABLES, {});
        module.exports = function (key) {
            ArrayProto[UNSCOPABLES][key] = true;
        };

        /***/
    }),
/* 70 */
/***/ (function (module, exports) {

        module.exports = function (it, Constructor, name, forbiddenField) {
            if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
                throw TypeError(name + ': incorrect invocation!');
            } return it;
        };

        /***/
    }),
/* 71 */
/***/ (function (module, exports, __webpack_require__) {

        // false -> Array#indexOf
        // true  -> Array#includes
        var toIObject = __webpack_require__(31)
            , toLength = __webpack_require__(44)
            , toIndex = __webpack_require__(91);
        module.exports = function (IS_INCLUDES) {
            return function ($this, el, fromIndex) {
                var O = toIObject($this)
                    , length = toLength(O.length)
                    , index = toIndex(fromIndex, length)
                    , value;
                // Array#includes uses SameValueZero equality algorithm
                if (IS_INCLUDES && el != el) while (length > index) {
                    value = O[index++];
                    if (value != value) return true;
                    // Array#toIndex ignores holes, Array#includes - not
                } else for (; length > index; index++)if (IS_INCLUDES || index in O) {
                    if (O[index] === el) return IS_INCLUDES || index || 0;
                } return !IS_INCLUDES && -1;
            };
        };

        /***/
    }),
/* 72 */
/***/ (function (module, exports, __webpack_require__) {

        var ctx = __webpack_require__(20)
            , call = __webpack_require__(77)
            , isArrayIter = __webpack_require__(76)
            , anObject = __webpack_require__(9)
            , toLength = __webpack_require__(44)
            , getIterFn = __webpack_require__(94)
            , BREAK = {}
            , RETURN = {};
        var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
            var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable)
                , f = ctx(fn, that, entries ? 2 : 1)
                , index = 0
                , length, step, iterator, result;
            if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
            // fast case for arrays with default iterator
            if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
                result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
                if (result === BREAK || result === RETURN) return result;
            } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
                result = call(iterator, f, step.value, entries);
                if (result === BREAK || result === RETURN) return result;
            }
        };
        exports.BREAK = BREAK;
        exports.RETURN = RETURN;

        /***/
    }),
/* 73 */
/***/ (function (module, exports, __webpack_require__) {

        module.exports = !__webpack_require__(13) && !__webpack_require__(37)(function () {
            return Object.defineProperty(__webpack_require__(27)('div'), 'a', { get: function () { return 7; } }).a != 7;
        });

        /***/
    }),
/* 74 */
/***/ (function (module, exports) {

        // fast apply, http://jsperf.lnkit.com/fast-apply/5
        module.exports = function (fn, args, that) {
            var un = that === undefined;
            switch (args.length) {
                case 0: return un ? fn()
                    : fn.call(that);
                case 1: return un ? fn(args[0])
                    : fn.call(that, args[0]);
                case 2: return un ? fn(args[0], args[1])
                    : fn.call(that, args[0], args[1]);
                case 3: return un ? fn(args[0], args[1], args[2])
                    : fn.call(that, args[0], args[1], args[2]);
                case 4: return un ? fn(args[0], args[1], args[2], args[3])
                    : fn.call(that, args[0], args[1], args[2], args[3]);
            } return fn.apply(that, args);
        };

        /***/
    }),
/* 75 */
/***/ (function (module, exports, __webpack_require__) {

        // fallback for non-array-like ES3 and non-enumerable old V8 strings
        var cof = __webpack_require__(19);
        module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
            return cof(it) == 'String' ? it.split('') : Object(it);
        };

        /***/
    }),
/* 76 */
/***/ (function (module, exports, __webpack_require__) {

        // check on default Array iterator
        var Iterators = __webpack_require__(15)
            , ITERATOR = __webpack_require__(1)('iterator')
            , ArrayProto = Array.prototype;

        module.exports = function (it) {
            return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
        };

        /***/
    }),
/* 77 */
/***/ (function (module, exports, __webpack_require__) {

        // call something on iterator step with safe closing on error
        var anObject = __webpack_require__(9);
        module.exports = function (iterator, fn, value, entries) {
            try {
                return entries ? fn(anObject(value)[0], value[1]) : fn(value);
                // 7.4.6 IteratorClose(iterator, completion)
            } catch (e) {
                var ret = iterator['return'];
                if (ret !== undefined) anObject(ret.call(iterator));
                throw e;
            }
        };

        /***/
    }),
/* 78 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";

        var create = __webpack_require__(82)
            , descriptor = __webpack_require__(41)
            , setToStringTag = __webpack_require__(28)
            , IteratorPrototype = {};

        // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
        __webpack_require__(10)(IteratorPrototype, __webpack_require__(1)('iterator'), function () { return this; });

        module.exports = function (Constructor, NAME, next) {
            Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
            setToStringTag(Constructor, NAME + ' Iterator');
        };

        /***/
    }),
/* 79 */
/***/ (function (module, exports, __webpack_require__) {

        var ITERATOR = __webpack_require__(1)('iterator')
            , SAFE_CLOSING = false;

        try {
            var riter = [7][ITERATOR]();
            riter['return'] = function () { SAFE_CLOSING = true; };
            Array.from(riter, function () { throw 2; });
        } catch (e) { /* empty */ }

        module.exports = function (exec, skipClosing) {
            if (!skipClosing && !SAFE_CLOSING) return false;
            var safe = false;
            try {
                var arr = [7]
                    , iter = arr[ITERATOR]();
                iter.next = function () { return { done: safe = true }; };
                arr[ITERATOR] = function () { return iter; };
                exec(arr);
            } catch (e) { /* empty */ }
            return safe;
        };

        /***/
    }),
/* 80 */
/***/ (function (module, exports) {

        module.exports = function (done, value) {
            return { value: value, done: !!done };
        };

        /***/
    }),
/* 81 */
/***/ (function (module, exports, __webpack_require__) {

        var global = __webpack_require__(3)
            , macrotask = __webpack_require__(43).set
            , Observer = global.MutationObserver || global.WebKitMutationObserver
            , process = global.process
            , Promise = global.Promise
            , isNode = __webpack_require__(19)(process) == 'process';

        module.exports = function () {
            var head, last, notify;

            var flush = function () {
                var parent, fn;
                if (isNode && (parent = process.domain)) parent.exit();
                while (head) {
                    fn = head.fn;
                    head = head.next;
                    try {
                        fn();
                    } catch (e) {
                        if (head) notify();
                        else last = undefined;
                        throw e;
                    }
                } last = undefined;
                if (parent) parent.enter();
            };

            // Node.js
            if (isNode) {
                notify = function () {
                    process.nextTick(flush);
                };
                // browsers with MutationObserver
            } else if (Observer) {
                var toggle = true
                    , node = document.createTextNode('');
                new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
                notify = function () {
                    node.data = toggle = !toggle;
                };
                // environments with maybe non-completely correct, but existent Promise
            } else if (Promise && Promise.resolve) {
                var promise = Promise.resolve();
                notify = function () {
                    promise.then(flush);
                };
                // for other environments - macrotask based on:
                // - setImmediate
                // - MessageChannel
                // - window.postMessag
                // - onreadystatechange
                // - setTimeout
            } else {
                notify = function () {
                    // strange IE + webpack dev server bug - use .call(global)
                    macrotask.call(global, flush);
                };
            }

            return function (fn) {
                var task = { fn: fn, next: undefined };
                if (last) last.next = task;
                if (!head) {
                    head = task;
                    notify();
                } last = task;
            };
        };

        /***/
    }),
/* 82 */
/***/ (function (module, exports, __webpack_require__) {

        // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
        var anObject = __webpack_require__(9)
            , dPs = __webpack_require__(83)
            , enumBugKeys = __webpack_require__(35)
            , IE_PROTO = __webpack_require__(29)('IE_PROTO')
            , Empty = function () { /* empty */ }
            , PROTOTYPE = 'prototype';

        // Create object with fake `null` prototype: use iframe Object with cleared prototype
        var createDict = function () {
            // Thrash, waste and sodomy: IE GC bug
            var iframe = __webpack_require__(27)('iframe')
                , i = enumBugKeys.length
                , lt = '<'
                , gt = '>'
                , iframeDocument;
            iframe.style.display = 'none';
            __webpack_require__(38).appendChild(iframe);
            iframe.src = 'javascript:'; // eslint-disable-line no-script-url
            // createDict = iframe.contentWindow.Object;
            // html.removeChild(iframe);
            iframeDocument = iframe.contentWindow.document;
            iframeDocument.open();
            iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
            iframeDocument.close();
            createDict = iframeDocument.F;
            while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
            return createDict();
        };

        module.exports = Object.create || function create(O, Properties) {
            var result;
            if (O !== null) {
                Empty[PROTOTYPE] = anObject(O);
                result = new Empty;
                Empty[PROTOTYPE] = null;
                // add "__proto__" for Object.getPrototypeOf polyfill
                result[IE_PROTO] = O;
            } else result = createDict();
            return Properties === undefined ? result : dPs(result, Properties);
        };


        /***/
    }),
/* 83 */
/***/ (function (module, exports, __webpack_require__) {

        var dP = __webpack_require__(22)
            , anObject = __webpack_require__(9)
            , getKeys = __webpack_require__(86);

        module.exports = __webpack_require__(13) ? Object.defineProperties : function defineProperties(O, Properties) {
            anObject(O);
            var keys = getKeys(Properties)
                , length = keys.length
                , i = 0
                , P;
            while (length > i) dP.f(O, P = keys[i++], Properties[P]);
            return O;
        };

        /***/
    }),
/* 84 */
/***/ (function (module, exports, __webpack_require__) {

        // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
        var has = __webpack_require__(14)
            , toObject = __webpack_require__(92)
            , IE_PROTO = __webpack_require__(29)('IE_PROTO')
            , ObjectProto = Object.prototype;

        module.exports = Object.getPrototypeOf || function (O) {
            O = toObject(O);
            if (has(O, IE_PROTO)) return O[IE_PROTO];
            if (typeof O.constructor == 'function' && O instanceof O.constructor) {
                return O.constructor.prototype;
            } return O instanceof Object ? ObjectProto : null;
        };

        /***/
    }),
/* 85 */
/***/ (function (module, exports, __webpack_require__) {

        var has = __webpack_require__(14)
            , toIObject = __webpack_require__(31)
            , arrayIndexOf = __webpack_require__(71)(false)
            , IE_PROTO = __webpack_require__(29)('IE_PROTO');

        module.exports = function (object, names) {
            var O = toIObject(object)
                , i = 0
                , result = []
                , key;
            for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
            // Don't enum bug & hidden keys
            while (names.length > i) if (has(O, key = names[i++])) {
                ~arrayIndexOf(result, key) || result.push(key);
            }
            return result;
        };

        /***/
    }),
/* 86 */
/***/ (function (module, exports, __webpack_require__) {

        // 19.1.2.14 / 15.2.3.14 Object.keys(O)
        var $keys = __webpack_require__(85)
            , enumBugKeys = __webpack_require__(35);

        module.exports = Object.keys || function keys(O) {
            return $keys(O, enumBugKeys);
        };

        /***/
    }),
/* 87 */
/***/ (function (module, exports, __webpack_require__) {

        var redefine = __webpack_require__(16);
        module.exports = function (target, src, safe) {
            for (var key in src) redefine(target, key, src[key], safe);
            return target;
        };

        /***/
    }),
/* 88 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";

        var global = __webpack_require__(3)
            , dP = __webpack_require__(22)
            , DESCRIPTORS = __webpack_require__(13)
            , SPECIES = __webpack_require__(1)('species');

        module.exports = function (KEY) {
            var C = global[KEY];
            if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
                configurable: true,
                get: function () { return this; }
            });
        };

        /***/
    }),
/* 89 */
/***/ (function (module, exports, __webpack_require__) {

        // 7.3.20 SpeciesConstructor(O, defaultConstructor)
        var anObject = __webpack_require__(9)
            , aFunction = __webpack_require__(24)
            , SPECIES = __webpack_require__(1)('species');
        module.exports = function (O, D) {
            var C = anObject(O).constructor, S;
            return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
        };

        /***/
    }),
/* 90 */
/***/ (function (module, exports, __webpack_require__) {

        var toInteger = __webpack_require__(30)
            , defined = __webpack_require__(26);
        // true  -> String#at
        // false -> String#codePointAt
        module.exports = function (TO_STRING) {
            return function (that, pos) {
                var s = String(defined(that))
                    , i = toInteger(pos)
                    , l = s.length
                    , a, b;
                if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
                a = s.charCodeAt(i);
                return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
                    ? TO_STRING ? s.charAt(i) : a
                    : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
            };
        };

        /***/
    }),
/* 91 */
/***/ (function (module, exports, __webpack_require__) {

        var toInteger = __webpack_require__(30)
            , max = Math.max
            , min = Math.min;
        module.exports = function (index, length) {
            index = toInteger(index);
            return index < 0 ? max(index + length, 0) : min(index, length);
        };

        /***/
    }),
/* 92 */
/***/ (function (module, exports, __webpack_require__) {

        // 7.1.13 ToObject(argument)
        var defined = __webpack_require__(26);
        module.exports = function (it) {
            return Object(defined(it));
        };

        /***/
    }),
/* 93 */
/***/ (function (module, exports, __webpack_require__) {

        // 7.1.1 ToPrimitive(input [, PreferredType])
        var isObject = __webpack_require__(21);
        // instead of the ES6 spec version, we didn't implement @@toPrimitive case
        // and the second argument - flag - preferred type is a string
        module.exports = function (it, S) {
            if (!isObject(it)) return it;
            var fn, val;
            if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
            if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
            if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
            throw TypeError("Can't convert object to primitive value");
        };

        /***/
    }),
/* 94 */
/***/ (function (module, exports, __webpack_require__) {

        var classof = __webpack_require__(25)
            , ITERATOR = __webpack_require__(1)('iterator')
            , Iterators = __webpack_require__(15);
        module.exports = __webpack_require__(12).getIteratorMethod = function (it) {
            if (it != undefined) return it[ITERATOR]
                || it['@@iterator']
                || Iterators[classof(it)];
        };

        /***/
    }),
/* 95 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";

        var addToUnscopables = __webpack_require__(69)
            , step = __webpack_require__(80)
            , Iterators = __webpack_require__(15)
            , toIObject = __webpack_require__(31);

        // 22.1.3.4 Array.prototype.entries()
        // 22.1.3.13 Array.prototype.keys()
        // 22.1.3.29 Array.prototype.values()
        // 22.1.3.30 Array.prototype[@@iterator]()
        module.exports = __webpack_require__(39)(Array, 'Array', function (iterated, kind) {
            this._t = toIObject(iterated); // target
            this._i = 0;                   // next index
            this._k = kind;                // kind
            // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
        }, function () {
            var O = this._t
                , kind = this._k
                , index = this._i++;
            if (!O || index >= O.length) {
                this._t = undefined;
                return step(1);
            }
            if (kind == 'keys') return step(0, index);
            if (kind == 'values') return step(0, O[index]);
            return step(0, [index, O[index]]);
        }, 'values');

        // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
        Iterators.Arguments = Iterators.Array;

        addToUnscopables('keys');
        addToUnscopables('values');
        addToUnscopables('entries');

        /***/
    }),
/* 96 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";

        // 19.1.3.6 Object.prototype.toString()
        var classof = __webpack_require__(25)
            , test = {};
        test[__webpack_require__(1)('toStringTag')] = 'z';
        if (test + '' != '[object z]') {
            __webpack_require__(16)(Object.prototype, 'toString', function toString() {
                return '[object ' + classof(this) + ']';
            }, true);
        }

        /***/
    }),
/* 97 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";

        var LIBRARY = __webpack_require__(40)
            , global = __webpack_require__(3)
            , ctx = __webpack_require__(20)
            , classof = __webpack_require__(25)
            , $export = __webpack_require__(36)
            , isObject = __webpack_require__(21)
            , aFunction = __webpack_require__(24)
            , anInstance = __webpack_require__(70)
            , forOf = __webpack_require__(72)
            , speciesConstructor = __webpack_require__(89)
            , task = __webpack_require__(43).set
            , microtask = __webpack_require__(81)()
            , PROMISE = 'Promise'
            , TypeError = global.TypeError
            , process = global.process
            , $Promise = global[PROMISE]
            , process = global.process
            , isNode = classof(process) == 'process'
            , empty = function () { /* empty */ }
            , Internal, GenericPromiseCapability, Wrapper;

        var USE_NATIVE = !!function () {
            try {
                // correct subclassing with @@species support
                var promise = $Promise.resolve(1)
                    , FakePromise = (promise.constructor = {})[__webpack_require__(1)('species')] = function (exec) { exec(empty, empty); };
                // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
                return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
            } catch (e) { /* empty */ }
        }();

        // helpers
        var sameConstructor = function (a, b) {
            // with library wrapper special case
            return a === b || a === $Promise && b === Wrapper;
        };
        var isThenable = function (it) {
            var then;
            return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
        };
        var newPromiseCapability = function (C) {
            return sameConstructor($Promise, C)
                ? new PromiseCapability(C)
                : new GenericPromiseCapability(C);
        };
        var PromiseCapability = GenericPromiseCapability = function (C) {
            var resolve, reject;
            this.promise = new C(function ($$resolve, $$reject) {
                if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
                resolve = $$resolve;
                reject = $$reject;
            });
            this.resolve = aFunction(resolve);
            this.reject = aFunction(reject);
        };
        var perform = function (exec) {
            try {
                exec();
            } catch (e) {
                return { error: e };
            }
        };
        var notify = function (promise, isReject) {
            if (promise._n) return;
            promise._n = true;
            var chain = promise._c;
            microtask(function () {
                var value = promise._v
                    , ok = promise._s == 1
                    , i = 0;
                var run = function (reaction) {
                    var handler = ok ? reaction.ok : reaction.fail
                        , resolve = reaction.resolve
                        , reject = reaction.reject
                        , domain = reaction.domain
                        , result, then;
                    try {
                        if (handler) {
                            if (!ok) {
                                if (promise._h == 2) onHandleUnhandled(promise);
                                promise._h = 1;
                            }
                            if (handler === true) result = value;
                            else {
                                if (domain) domain.enter();
                                result = handler(value);
                                if (domain) domain.exit();
                            }
                            if (result === reaction.promise) {
                                reject(TypeError('Promise-chain cycle'));
                            } else if (then = isThenable(result)) {
                                then.call(result, resolve, reject);
                            } else resolve(result);
                        } else reject(value);
                    } catch (e) {
                        reject(e);
                    }
                };
                while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
                promise._c = [];
                promise._n = false;
                if (isReject && !promise._h) onUnhandled(promise);
            });
        };
        var onUnhandled = function (promise) {
            task.call(global, function () {
                var value = promise._v
                    , abrupt, handler, console;
                if (isUnhandled(promise)) {
                    abrupt = perform(function () {
                        if (isNode) {
                            process.emit('unhandledRejection', value, promise);
                        } else if (handler = global.onunhandledrejection) {
                            handler({ promise: promise, reason: value });
                        } else if ((console = global.console) && console.error) {
                            console.error('Unhandled promise rejection', value);
                        }
                    });
                    // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
                    promise._h = isNode || isUnhandled(promise) ? 2 : 1;
                } promise._a = undefined;
                if (abrupt) throw abrupt.error;
            });
        };
        var isUnhandled = function (promise) {
            if (promise._h == 1) return false;
            var chain = promise._a || promise._c
                , i = 0
                , reaction;
            while (chain.length > i) {
                reaction = chain[i++];
                if (reaction.fail || !isUnhandled(reaction.promise)) return false;
            } return true;
        };
        var onHandleUnhandled = function (promise) {
            task.call(global, function () {
                var handler;
                if (isNode) {
                    process.emit('rejectionHandled', promise);
                } else if (handler = global.onrejectionhandled) {
                    handler({ promise: promise, reason: promise._v });
                }
            });
        };
        var $reject = function (value) {
            var promise = this;
            if (promise._d) return;
            promise._d = true;
            promise = promise._w || promise; // unwrap
            promise._v = value;
            promise._s = 2;
            if (!promise._a) promise._a = promise._c.slice();
            notify(promise, true);
        };
        var $resolve = function (value) {
            var promise = this
                , then;
            if (promise._d) return;
            promise._d = true;
            promise = promise._w || promise; // unwrap
            try {
                if (promise === value) throw TypeError("Promise can't be resolved itself");
                if (then = isThenable(value)) {
                    microtask(function () {
                        var wrapper = { _w: promise, _d: false }; // wrap
                        try {
                            then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
                        } catch (e) {
                            $reject.call(wrapper, e);
                        }
                    });
                } else {
                    promise._v = value;
                    promise._s = 1;
                    notify(promise, false);
                }
            } catch (e) {
                $reject.call({ _w: promise, _d: false }, e); // wrap
            }
        };

        // constructor polyfill
        if (!USE_NATIVE) {
            // 25.4.3.1 Promise(executor)
            $Promise = function Promise(executor) {
                anInstance(this, $Promise, PROMISE, '_h');
                aFunction(executor);
                Internal.call(this);
                try {
                    executor(ctx($resolve, this, 1), ctx($reject, this, 1));
                } catch (err) {
                    $reject.call(this, err);
                }
            };
            Internal = function Promise(executor) {
                this._c = [];             // <- awaiting reactions
                this._a = undefined;      // <- checked in isUnhandled reactions
                this._s = 0;              // <- state
                this._d = false;          // <- done
                this._v = undefined;      // <- value
                this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
                this._n = false;          // <- notify
            };
            Internal.prototype = __webpack_require__(87)($Promise.prototype, {
                // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
                then: function then(onFulfilled, onRejected) {
                    var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
                    reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
                    reaction.fail = typeof onRejected == 'function' && onRejected;
                    reaction.domain = isNode ? process.domain : undefined;
                    this._c.push(reaction);
                    if (this._a) this._a.push(reaction);
                    if (this._s) notify(this, false);
                    return reaction.promise;
                },
                // 25.4.5.1 Promise.prototype.catch(onRejected)
                'catch': function (onRejected) {
                    return this.then(undefined, onRejected);
                }
            });
            PromiseCapability = function () {
                var promise = new Internal;
                this.promise = promise;
                this.resolve = ctx($resolve, promise, 1);
                this.reject = ctx($reject, promise, 1);
            };
        }

        $export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });
        __webpack_require__(28)($Promise, PROMISE);
        __webpack_require__(88)(PROMISE);
        Wrapper = __webpack_require__(12)[PROMISE];

        // statics
        $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
            // 25.4.4.5 Promise.reject(r)
            reject: function reject(r) {
                var capability = newPromiseCapability(this)
                    , $$reject = capability.reject;
                $$reject(r);
                return capability.promise;
            }
        });
        $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
            // 25.4.4.6 Promise.resolve(x)
            resolve: function resolve(x) {
                // instanceof instead of internal slot check because we should fix it without replacement native Promise core
                if (x instanceof $Promise && sameConstructor(x.constructor, this)) return x;
                var capability = newPromiseCapability(this)
                    , $$resolve = capability.resolve;
                $$resolve(x);
                return capability.promise;
            }
        });
        $export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(79)(function (iter) {
            $Promise.all(iter)['catch'](empty);
        })), PROMISE, {
            // 25.4.4.1 Promise.all(iterable)
            all: function all(iterable) {
                var C = this
                    , capability = newPromiseCapability(C)
                    , resolve = capability.resolve
                    , reject = capability.reject;
                var abrupt = perform(function () {
                    var values = []
                        , index = 0
                        , remaining = 1;
                    forOf(iterable, false, function (promise) {
                        var $index = index++
                            , alreadyCalled = false;
                        values.push(undefined);
                        remaining++;
                        C.resolve(promise).then(function (value) {
                            if (alreadyCalled) return;
                            alreadyCalled = true;
                            values[$index] = value;
                            --remaining || resolve(values);
                        }, reject);
                    });
                    --remaining || resolve(values);
                });
                if (abrupt) reject(abrupt.error);
                return capability.promise;
            },
            // 25.4.4.4 Promise.race(iterable)
            race: function race(iterable) {
                var C = this
                    , capability = newPromiseCapability(C)
                    , reject = capability.reject;
                var abrupt = perform(function () {
                    forOf(iterable, false, function (promise) {
                        C.resolve(promise).then(capability.resolve, reject);
                    });
                });
                if (abrupt) reject(abrupt.error);
                return capability.promise;
            }
        });

        /***/
    }),
/* 98 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";

        var $at = __webpack_require__(90)(true);

        // 21.1.3.27 String.prototype[@@iterator]()
        __webpack_require__(39)(String, 'String', function (iterated) {
            this._t = String(iterated); // target
            this._i = 0;                // next index
            // 21.1.5.2.1 %StringIteratorPrototype%.next()
        }, function () {
            var O = this._t
                , index = this._i
                , point;
            if (index >= O.length) return { value: undefined, done: true };
            point = $at(O, index);
            this._i += point.length;
            return { value: point, done: false };
        });

        /***/
    }),
/* 99 */
/***/ (function (module, exports, __webpack_require__) {

        var $iterators = __webpack_require__(95)
            , redefine = __webpack_require__(16)
            , global = __webpack_require__(3)
            , hide = __webpack_require__(10)
            , Iterators = __webpack_require__(15)
            , wks = __webpack_require__(1)
            , ITERATOR = wks('iterator')
            , TO_STRING_TAG = wks('toStringTag')
            , ArrayValues = Iterators.Array;

        for (var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++) {
            var NAME = collections[i]
                , Collection = global[NAME]
                , proto = Collection && Collection.prototype
                , key;
            if (proto) {
                if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);
                if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
                Iterators[NAME] = ArrayValues;
                for (key in $iterators) if (!proto[key]) redefine(proto, key, $iterators[key], true);
            }
        }

        /***/
    }),
/* 100 */
/***/ (function (module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function ($, jQuery) {/*
 * easy-autocomplete
 * jQuery plugin for autocompletion
 * 
 * @author Łukasz Pawełczak (http://github.com/pawelczak)
 * @version 1.3.5
 * Copyright  License: 
 */

            /*
             * EasyAutocomplete - Configuration 
             */
            var EasyAutocomplete = (function (scope) {

                scope.Configuration = function Configuration(options) {
                    var defaults = {
                        data: "list-required",
                        url: "list-required",
                        dataType: "json",

                        listLocation: function (data) {
                            return data;
                        },

                        xmlElementName: "",

                        getValue: function (element) {
                            return element;
                        },

                        autocompleteOff: true,

                        placeholder: false,

                        ajaxCallback: function () { },

                        matchResponseProperty: false,

                        list: {
                            sort: {
                                enabled: false,
                                method: function (a, b) {
                                    a = defaults.getValue(a);
                                    b = defaults.getValue(b);
                                    if (a < b) {
                                        return -1;
                                    }
                                    if (a > b) {
                                        return 1;
                                    }
                                    return 0;
                                }
                            },

                            maxNumberOfElements: 6,

                            hideOnEmptyPhrase: true,

                            match: {
                                enabled: false,
                                caseSensitive: false,
                                method: function (element, phrase) {

                                    if (element.search(phrase) > -1) {
                                        return true;
                                    } else {
                                        return false;
                                    }
                                }
                            },

                            showAnimation: {
                                type: "normal", //normal|slide|fade
                                time: 400,
                                callback: function () { }
                            },

                            hideAnimation: {
                                type: "normal",
                                time: 400,
                                callback: function () { }
                            },

                            /* Events */
                            onClickEvent: function () { },
                            onSelectItemEvent: function () { },
                            onLoadEvent: function () { },
                            onChooseEvent: function () { },
                            onKeyEnterEvent: function () { },
                            onMouseOverEvent: function () { },
                            onMouseOutEvent: function () { },
                            onShowListEvent: function () { },
                            onHideListEvent: function () { }
                        },

                        highlightPhrase: true,

                        theme: "",

                        cssClasses: "",

                        minCharNumber: 0,

                        requestDelay: 0,

                        adjustWidth: true,

                        ajaxSettings: {},

                        preparePostData: function (data, inputPhrase) { return data; },

                        loggerEnabled: true,

                        template: "",

                        categoriesAssigned: false,

                        categories: [{
                            maxNumberOfElements: 4
                        }]

                    };

                    var externalObjects = ["ajaxSettings", "template"];

                    this.get = function (propertyName) {
                        return defaults[propertyName];
                    };

                    this.equals = function (name, value) {
                        if (isAssigned(name)) {
                            if (defaults[name] === value) {
                                return true;
                            }
                        }

                        return false;
                    };

                    this.checkDataUrlProperties = function () {
                        if (defaults.url === "list-required" && defaults.data === "list-required") {
                            return false;
                        }
                        return true;
                    };
                    this.checkRequiredProperties = function () {
                        for (var propertyName in defaults) {
                            if (defaults[propertyName] === "required") {
                                logger.error("Option " + propertyName + " must be defined");
                                return false;
                            }
                        }
                        return true;
                    };

                    this.printPropertiesThatDoesntExist = function (consol, optionsToCheck) {
                        printPropertiesThatDoesntExist(consol, optionsToCheck);
                    };


                    prepareDefaults();

                    mergeOptions();

                    if (defaults.loggerEnabled === true) {
                        printPropertiesThatDoesntExist(console, options);
                    }

                    addAjaxSettings();

                    processAfterMerge();
                    function prepareDefaults() {

                        if (options.dataType === "xml") {

                            if (!options.getValue) {

                                options.getValue = function (element) {
                                    return $(element).text();
                                };
                            }


                            if (!options.list) {

                                options.list = {};
                            }

                            if (!options.list.sort) {
                                options.list.sort = {};
                            }


                            options.list.sort.method = function (a, b) {
                                a = options.getValue(a);
                                b = options.getValue(b);
                                if (a < b) {
                                    return -1;
                                }
                                if (a > b) {
                                    return 1;
                                }
                                return 0;
                            };

                            if (!options.list.match) {
                                options.list.match = {};
                            }

                            options.list.match.method = function (element, phrase) {

                                if (element.search(phrase) > -1) {
                                    return true;
                                } else {
                                    return false;
                                }
                            };

                        }
                        if (options.categories !== undefined && options.categories instanceof Array) {

                            var categories = [];

                            for (var i = 0, length = options.categories.length; i < length; i += 1) {

                                var category = options.categories[i];

                                for (var property in defaults.categories[0]) {

                                    if (category[property] === undefined) {
                                        category[property] = defaults.categories[0][property];
                                    }
                                }

                                categories.push(category);
                            }

                            options.categories = categories;
                        }
                    }

                    function mergeOptions() {

                        defaults = mergeObjects(defaults, options);

                        function mergeObjects(source, target) {
                            var mergedObject = source || {};

                            for (var propertyName in source) {
                                if (target[propertyName] !== undefined && target[propertyName] !== null) {

                                    if (typeof target[propertyName] !== "object" ||
                                        target[propertyName] instanceof Array) {
                                        mergedObject[propertyName] = target[propertyName];
                                    } else {
                                        mergeObjects(source[propertyName], target[propertyName]);
                                    }
                                }
                            }

                            /* If data is an object */
                            if (target.data !== undefined && target.data !== null && typeof target.data === "object") {
                                mergedObject.data = target.data;
                            }

                            return mergedObject;
                        }
                    }


                    function processAfterMerge() {

                        if (defaults.url !== "list-required" && typeof defaults.url !== "function") {
                            var defaultUrl = defaults.url;
                            defaults.url = function () {
                                return defaultUrl;
                            };
                        }

                        if (defaults.ajaxSettings.url !== undefined && typeof defaults.ajaxSettings.url !== "function") {
                            var defaultUrl = defaults.ajaxSettings.url;
                            defaults.ajaxSettings.url = function () {
                                return defaultUrl;
                            };
                        }

                        if (typeof defaults.listLocation === "string") {
                            var defaultlistLocation = defaults.listLocation;

                            if (defaults.dataType.toUpperCase() === "XML") {
                                defaults.listLocation = function (data) {
                                    return $(data).find(defaultlistLocation);
                                };
                            } else {
                                defaults.listLocation = function (data) {
                                    return data[defaultlistLocation];
                                };
                            }
                        }

                        if (typeof defaults.getValue === "string") {
                            var defaultsGetValue = defaults.getValue;
                            defaults.getValue = function (element) {
                                return element[defaultsGetValue];
                            };
                        }

                        if (options.categories !== undefined) {
                            defaults.categoriesAssigned = true;
                        }

                    }

                    function addAjaxSettings() {

                        if (options.ajaxSettings !== undefined && typeof options.ajaxSettings === "object") {
                            defaults.ajaxSettings = options.ajaxSettings;
                        } else {
                            defaults.ajaxSettings = {};
                        }

                    }

                    function isAssigned(name) {
                        if (defaults[name] !== undefined && defaults[name] !== null) {
                            return true;
                        } else {
                            return false;
                        }
                    }
                    function printPropertiesThatDoesntExist(consol, optionsToCheck) {

                        checkPropertiesIfExist(defaults, optionsToCheck);

                        function checkPropertiesIfExist(source, target) {
                            for (var property in target) {
                                if (source[property] === undefined) {
                                    consol.log("Property '" + property + "' does not exist in EasyAutocomplete options API.");
                                }

                                if (typeof source[property] === "object" && $.inArray(property, externalObjects) === -1) {
                                    checkPropertiesIfExist(source[property], target[property]);
                                }
                            }
                        }
                    }
                };

                return scope;

            })(EasyAutocomplete || {});


            /*
             * EasyAutocomplete - Logger 
             */
            var EasyAutocomplete = (function (scope) {

                scope.Logger = function Logger() {

                    this.error = function (message) {
                        console.log("ERROR: " + message);
                    };

                    this.warning = function (message) {
                        console.log("WARNING: " + message);
                    };
                };

                return scope;

            })(EasyAutocomplete || {});


            /*
             * EasyAutocomplete - Constans
             */
            var EasyAutocomplete = (function (scope) {

                scope.Constans = function Constans() {
                    var constants = {
                        CONTAINER_CLASS: "easy-autocomplete-container",
                        CONTAINER_ID: "eac-container-",

                        WRAPPER_CSS_CLASS: "easy-autocomplete"
                    };

                    this.getValue = function (propertyName) {
                        return constants[propertyName];
                    };

                };

                return scope;

            })(EasyAutocomplete || {});

            /*
             * EasyAutocomplete - ListBuilderService 
             *
             * @author Łukasz Pawełczak 
             *
             */
            var EasyAutocomplete = (function (scope) {

                scope.ListBuilderService = function ListBuilderService(configuration, proccessResponseData) {


                    this.init = function (data) {
                        var listBuilder = [],
                            builder = {};

                        builder.data = configuration.get("listLocation")(data);
                        builder.getValue = configuration.get("getValue");
                        builder.maxListSize = configuration.get("list").maxNumberOfElements;


                        listBuilder.push(builder);

                        return listBuilder;
                    };

                    this.updateCategories = function (listBuilder, data) {

                        if (configuration.get("categoriesAssigned")) {

                            listBuilder = [];

                            for (var i = 0; i < configuration.get("categories").length; i += 1) {

                                var builder = convertToListBuilder(configuration.get("categories")[i], data);

                                listBuilder.push(builder);
                            }

                        }

                        return listBuilder;
                    };

                    this.convertXml = function (listBuilder) {
                        if (configuration.get("dataType").toUpperCase() === "XML") {

                            for (var i = 0; i < listBuilder.length; i += 1) {
                                listBuilder[i].data = convertXmlToList(listBuilder[i]);
                            }
                        }

                        return listBuilder;
                    };

                    this.processData = function (listBuilder, inputPhrase) {

                        for (var i = 0, length = listBuilder.length; i < length; i += 1) {
                            listBuilder[i].data = proccessResponseData(configuration, listBuilder[i], inputPhrase);
                        }

                        return listBuilder;
                    };

                    this.checkIfDataExists = function (listBuilders) {

                        for (var i = 0, length = listBuilders.length; i < length; i += 1) {

                            if (listBuilders[i].data !== undefined && listBuilders[i].data instanceof Array) {
                                if (listBuilders[i].data.length > 0) {
                                    return true;
                                }
                            }
                        }

                        return false;
                    };


                    function convertToListBuilder(category, data) {

                        var builder = {};

                        if (configuration.get("dataType").toUpperCase() === "XML") {

                            builder = convertXmlToListBuilder();
                        } else {

                            builder = convertDataToListBuilder();
                        }


                        if (category.header !== undefined) {
                            builder.header = category.header;
                        }

                        if (category.maxNumberOfElements !== undefined) {
                            builder.maxNumberOfElements = category.maxNumberOfElements;
                        }

                        if (configuration.get("list").maxNumberOfElements !== undefined) {

                            builder.maxListSize = configuration.get("list").maxNumberOfElements;
                        }

                        if (category.getValue !== undefined) {

                            if (typeof category.getValue === "string") {
                                var defaultsGetValue = category.getValue;
                                builder.getValue = function (element) {
                                    return element[defaultsGetValue];
                                };
                            } else if (typeof category.getValue === "function") {
                                builder.getValue = category.getValue;
                            }

                        } else {
                            builder.getValue = configuration.get("getValue");
                        }


                        return builder;


                        function convertXmlToListBuilder() {

                            var builder = {},
                                listLocation;

                            if (category.xmlElementName !== undefined) {
                                builder.xmlElementName = category.xmlElementName;
                            }

                            if (category.listLocation !== undefined) {

                                listLocation = category.listLocation;
                            } else if (configuration.get("listLocation") !== undefined) {

                                listLocation = configuration.get("listLocation");
                            }

                            if (listLocation !== undefined) {
                                if (typeof listLocation === "string") {
                                    builder.data = $(data).find(listLocation);
                                } else if (typeof listLocation === "function") {

                                    builder.data = listLocation(data);
                                }
                            } else {

                                builder.data = data;
                            }

                            return builder;
                        }


                        function convertDataToListBuilder() {

                            var builder = {};

                            if (category.listLocation !== undefined) {

                                if (typeof category.listLocation === "string") {
                                    builder.data = data[category.listLocation];
                                } else if (typeof category.listLocation === "function") {
                                    builder.data = category.listLocation(data);
                                }
                            } else {
                                builder.data = data;
                            }

                            return builder;
                        }
                    }

                    function convertXmlToList(builder) {
                        var simpleList = [];

                        if (builder.xmlElementName === undefined) {
                            builder.xmlElementName = configuration.get("xmlElementName");
                        }


                        $(builder.data).find(builder.xmlElementName).each(function () {
                            simpleList.push(this);
                        });

                        return simpleList;
                    }

                };

                return scope;

            })(EasyAutocomplete || {});


            /*
             * EasyAutocomplete - Data proccess module
             *
             * Process list to display:
             * - sort 
             * - decrease number to specific number
             * - show only matching list
             *
             */
            var EasyAutocomplete = (function (scope) {

                scope.proccess = function proccessData(config, listBuilder, phrase) {

                    scope.proccess.match = match;

                    var list = listBuilder.data,
                        inputPhrase = phrase;//TODO REFACTOR

                    list = findMatch(list, inputPhrase);
                    list = reduceElementsInList(list);
                    list = sort(list);

                    return list;


                    function findMatch(list, phrase) {
                        var preparedList = [],
                            value = "";

                        if (config.get("list").match.enabled) {

                            for (var i = 0, length = list.length; i < length; i += 1) {

                                value = config.get("getValue")(list[i]);

                                if (match(value, phrase)) {
                                    preparedList.push(list[i]);
                                }

                            }

                        } else {
                            preparedList = list;
                        }

                        return preparedList;
                    }

                    function match(value, phrase) {

                        if (!config.get("list").match.caseSensitive) {

                            if (typeof value === "string") {
                                value = value.toLowerCase();
                            }

                            phrase = phrase.toLowerCase();
                        }
                        if (config.get("list").match.method(value, phrase)) {
                            return true;
                        } else {
                            return false;
                        }
                    }

                    function reduceElementsInList(list) {
                        if (listBuilder.maxNumberOfElements !== undefined && list.length > listBuilder.maxNumberOfElements) {
                            list = list.slice(0, listBuilder.maxNumberOfElements);
                        }

                        return list;
                    }

                    function sort(list) {
                        if (config.get("list").sort.enabled) {
                            list.sort(config.get("list").sort.method);
                        }

                        return list;
                    }

                };


                return scope;


            })(EasyAutocomplete || {});


            /*
             * EasyAutocomplete - Template 
             *
             * 
             *
             */
            var EasyAutocomplete = (function (scope) {

                scope.Template = function Template(options) {


                    var genericTemplates = {
                        basic: {
                            type: "basic",
                            method: function (element) { return element; },
                            cssClass: ""
                        },
                        description: {
                            type: "description",
                            fields: {
                                description: "description"
                            },
                            method: function (element) { return element + " - description"; },
                            cssClass: "eac-description"
                        },
                        iconLeft: {
                            type: "iconLeft",
                            fields: {
                                icon: ""
                            },
                            method: function (element) {
                                return element;
                            },
                            cssClass: "eac-icon-left"
                        },
                        iconRight: {
                            type: "iconRight",
                            fields: {
                                iconSrc: ""
                            },
                            method: function (element) {
                                return element;
                            },
                            cssClass: "eac-icon-right"
                        },
                        links: {
                            type: "links",
                            fields: {
                                link: ""
                            },
                            method: function (element) {
                                return element;
                            },
                            cssClass: ""
                        },
                        custom: {
                            type: "custom",
                            method: function () { },
                            cssClass: ""
                        }
                    },



                        /*
                         * Converts method with {{text}} to function
                         */
                        convertTemplateToMethod = function (template) {


                            var _fields = template.fields,
                                buildMethod;

                            if (template.type === "description") {

                                buildMethod = genericTemplates.description.method;

                                if (typeof _fields.description === "string") {
                                    buildMethod = function (elementValue, element) {
                                        return elementValue + " - <span>" + element[_fields.description] + "</span>";
                                    };
                                } else if (typeof _fields.description === "function") {
                                    buildMethod = function (elementValue, element) {
                                        return elementValue + " - <span>" + _fields.description(element) + "</span>";
                                    };
                                }

                                return buildMethod;
                            }

                            if (template.type === "iconRight") {

                                if (typeof _fields.iconSrc === "string") {
                                    buildMethod = function (elementValue, element) {
                                        return elementValue + "<img class='eac-icon' src='" + element[_fields.iconSrc] + "' />";
                                    };
                                } else if (typeof _fields.iconSrc === "function") {
                                    buildMethod = function (elementValue, element) {
                                        return elementValue + "<img class='eac-icon' src='" + _fields.iconSrc(element) + "' />";
                                    };
                                }

                                return buildMethod;
                            }


                            if (template.type === "iconLeft") {

                                if (typeof _fields.iconSrc === "string") {
                                    buildMethod = function (elementValue, element) {
                                        return "<img class='eac-icon' src='" + element[_fields.iconSrc] + "' />" + elementValue;
                                    };
                                } else if (typeof _fields.iconSrc === "function") {
                                    buildMethod = function (elementValue, element) {
                                        return "<img class='eac-icon' src='" + _fields.iconSrc(element) + "' />" + elementValue;
                                    };
                                }

                                return buildMethod;
                            }

                            if (template.type === "links") {

                                if (typeof _fields.link === "string") {
                                    buildMethod = function (elementValue, element) {
                                        return "<a href='" + element[_fields.link] + "' >" + elementValue + "</a>";
                                    };
                                } else if (typeof _fields.link === "function") {
                                    buildMethod = function (elementValue, element) {
                                        return "<a href='" + _fields.link(element) + "' >" + elementValue + "</a>";
                                    };
                                }

                                return buildMethod;
                            }


                            if (template.type === "custom") {

                                return template.method;
                            }

                            return genericTemplates.basic.method;

                        },


                        prepareBuildMethod = function (options) {
                            if (!options || !options.type) {

                                return genericTemplates.basic.method;
                            }

                            if (options.type && genericTemplates[options.type]) {

                                return convertTemplateToMethod(options);
                            } else {

                                return genericTemplates.basic.method;
                            }

                        },

                        templateClass = function (options) {
                            var emptyStringFunction = function () { return ""; };

                            if (!options || !options.type) {

                                return emptyStringFunction;
                            }

                            if (options.type && genericTemplates[options.type]) {
                                return (function () {
                                    var _cssClass = genericTemplates[options.type].cssClass;
                                    return function () { return _cssClass; };
                                })();
                            } else {
                                return emptyStringFunction;
                            }
                        };


                    this.getTemplateClass = templateClass(options);

                    this.build = prepareBuildMethod(options);


                };

                return scope;

            })(EasyAutocomplete || {});


            /*
             * EasyAutocomplete - jQuery plugin for autocompletion
             *
             */
            var EasyAutocomplete = (function (scope) {


                scope.main = function Core($input, options) {

                    var module = {
                        name: "EasyAutocomplete",
                        shortcut: "eac"
                    };

                    var consts = new scope.Constans(),
                        config = new scope.Configuration(options),
                        logger = new scope.Logger(),
                        template = new scope.Template(options.template),
                        listBuilderService = new scope.ListBuilderService(config, scope.proccess),
                        checkParam = config.equals,

                        $field = $input,
                        $container = "",
                        elementsList = [],
                        selectedElement = -1,
                        requestDelayTimeoutId;

                    scope.consts = consts;

                    this.getConstants = function () {
                        return consts;
                    };

                    this.getConfiguration = function () {
                        return config;
                    };

                    this.getContainer = function () {
                        return $container;
                    };

                    this.getSelectedItemIndex = function () {
                        return selectedElement;
                    };

                    this.getItems = function () {
                        return elementsList;
                    };

                    this.getItemData = function (index) {

                        if (elementsList.length < index || elementsList[index] === undefined) {
                            return -1;
                        } else {
                            return elementsList[index];
                        }
                    };

                    this.getSelectedItemData = function () {
                        return this.getItemData(selectedElement);
                    };

                    this.build = function () {
                        prepareField();
                    };

                    this.init = function () {
                        init();
                    };
                    function init() {

                        if ($field.length === 0) {
                            logger.error("Input field doesn't exist.");
                            return;
                        }

                        if (!config.checkDataUrlProperties()) {
                            logger.error("One of options variables 'data' or 'url' must be defined.");
                            return;
                        }

                        if (!config.checkRequiredProperties()) {
                            logger.error("Will not work without mentioned properties.");
                            return;
                        }


                        prepareField();
                        bindEvents();

                    }
                    function prepareField() {


                        if ($field.parent().hasClass(consts.getValue("WRAPPER_CSS_CLASS"))) {
                            removeContainer();
                            removeWrapper();
                        }

                        createWrapper();
                        createContainer();

                        $container = $("#" + getContainerId());
                        if (config.get("placeholder")) {
                            $field.attr("placeholder", config.get("placeholder"));
                        }


                        function createWrapper() {
                            var $wrapper = $("<div>"),
                                classes = consts.getValue("WRAPPER_CSS_CLASS");


                            if (config.get("theme") && config.get("theme") !== "") {
                                classes += " eac-" + config.get("theme");
                            }

                            if (config.get("cssClasses") && config.get("cssClasses") !== "") {
                                classes += " " + config.get("cssClasses");
                            }

                            if (template.getTemplateClass() !== "") {
                                classes += " " + template.getTemplateClass();
                            }


                            $wrapper
                                .addClass(classes);
                            $field.wrap($wrapper);


                            if (config.get("adjustWidth") === true) {
                                adjustWrapperWidth();
                            }


                        }

                        function adjustWrapperWidth() {
                            var fieldWidth = $field.outerWidth();

                            $field.parent().css("width", fieldWidth);
                        }

                        function removeWrapper() {
                            $field.unwrap();
                        }

                        function createContainer() {
                            var $elements_container = $("<div>").addClass(consts.getValue("CONTAINER_CLASS"));

                            $elements_container
                                .attr("id", getContainerId())
                                .prepend($("<ul>"));


                            (function () {

                                $elements_container
                                    /* List show animation */
                                    .on("show.eac", function () {

                                        switch (config.get("list").showAnimation.type) {

                                            case "slide":
                                                var animationTime = config.get("list").showAnimation.time,
                                                    callback = config.get("list").showAnimation.callback;

                                                $elements_container.find("ul").slideDown(animationTime, callback);
                                                break;

                                            case "fade":
                                                var animationTime = config.get("list").showAnimation.time,
                                                    callback = config.get("list").showAnimation.callback;

                                                $elements_container.find("ul").fadeIn(animationTime), callback;
                                                break;

                                            default:
                                                $elements_container.find("ul").show();
                                                break;
                                        }

                                        config.get("list").onShowListEvent();

                                    })
                                    /* List hide animation */
                                    .on("hide.eac", function () {

                                        switch (config.get("list").hideAnimation.type) {

                                            case "slide":
                                                var animationTime = config.get("list").hideAnimation.time,
                                                    callback = config.get("list").hideAnimation.callback;

                                                $elements_container.find("ul").slideUp(animationTime, callback);
                                                break;

                                            case "fade":
                                                var animationTime = config.get("list").hideAnimation.time,
                                                    callback = config.get("list").hideAnimation.callback;

                                                $elements_container.find("ul").fadeOut(animationTime, callback);
                                                break;

                                            default:
                                                $elements_container.find("ul").hide();
                                                break;
                                        }

                                        config.get("list").onHideListEvent();

                                    })
                                    .on("selectElement.eac", function () {
                                        $elements_container.find("ul li").removeClass("selected");
                                        $elements_container.find("ul li").eq(selectedElement).addClass("selected");

                                        config.get("list").onSelectItemEvent();
                                    })
                                    .on("loadElements.eac", function (event, listBuilders, phrase) {


                                        var $item = "",
                                            $listContainer = $elements_container.find("ul");

                                        $listContainer
                                            .empty()
                                            .detach();

                                        elementsList = [];
                                        var counter = 0;
                                        for (var builderIndex = 0, listBuildersLength = listBuilders.length; builderIndex < listBuildersLength; builderIndex += 1) {

                                            var listData = listBuilders[builderIndex].data;

                                            if (listData.length === 0) {
                                                continue;
                                            }

                                            if (listBuilders[builderIndex].header !== undefined && listBuilders[builderIndex].header.length > 0) {
                                                $listContainer.append("<div class='eac-category' >" + listBuilders[builderIndex].header + "</div>");
                                            }

                                            for (var i = 0, listDataLength = listData.length; i < listDataLength && counter < listBuilders[builderIndex].maxListSize; i += 1) {
                                                $item = $("<li><div class='eac-item'></div></li>");


                                                (function () {
                                                    var j = i,
                                                        itemCounter = counter,
                                                        elementsValue = listBuilders[builderIndex].getValue(listData[j]);

                                                    $item.find(" > div")
                                                        .on("click", function () {

                                                            $field.val(elementsValue).trigger("change");

                                                            selectedElement = itemCounter;
                                                            selectElement(itemCounter);

                                                            config.get("list").onClickEvent();
                                                            config.get("list").onChooseEvent();
                                                        })
                                                        .mouseover(function () {

                                                            selectedElement = itemCounter;
                                                            selectElement(itemCounter);

                                                            config.get("list").onMouseOverEvent();
                                                        })
                                                        .mouseout(function () {
                                                            config.get("list").onMouseOutEvent();
                                                        })
                                                        .html(template.build(highlight(elementsValue, phrase), listData[j]));
                                                })();

                                                $listContainer.append($item);
                                                elementsList.push(listData[i]);
                                                counter += 1;
                                            }
                                        }

                                        $elements_container.append($listContainer);

                                        config.get("list").onLoadEvent();
                                    });

                            })();

                            $field.after($elements_container);
                        }

                        function removeContainer() {
                            $field.next("." + consts.getValue("CONTAINER_CLASS")).remove();
                        }

                        function highlight(string, phrase) {

                            if (config.get("highlightPhrase") && phrase !== "") {
                                return highlightPhrase(string, phrase);
                            } else {
                                return string;
                            }

                        }

                        function escapeRegExp(str) {
                            return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
                        }

                        function highlightPhrase(string, phrase) {
                            var escapedPhrase = escapeRegExp(phrase);
                            return (string + "").replace(new RegExp("(" + escapedPhrase + ")", "gi"), "<b>$1</b>");
                        }



                    }
                    function getContainerId() {

                        var elementId = $field.attr("id");

                        elementId = consts.getValue("CONTAINER_ID") + elementId;

                        return elementId;
                    }
                    function bindEvents() {

                        bindAllEvents();


                        function bindAllEvents() {
                            if (checkParam("autocompleteOff", true)) {
                                removeAutocomplete();
                            }

                            bindFocusOut();
                            bindKeyup();
                            bindKeydown();
                            bindKeypress();
                            bindFocus();
                            bindBlur();
                        }

                        function bindFocusOut() {
                            $field.focusout(function () {

                                var fieldValue = $field.val(),
                                    phrase;

                                if (!config.get("list").match.caseSensitive) {
                                    fieldValue = fieldValue.toLowerCase();
                                }

                                for (var i = 0, length = elementsList.length; i < length; i += 1) {

                                    phrase = config.get("getValue")(elementsList[i]);
                                    if (!config.get("list").match.caseSensitive) {
                                        phrase = phrase.toLowerCase();
                                    }

                                    if (phrase === fieldValue) {
                                        selectedElement = i;
                                        selectElement(selectedElement);
                                        return;
                                    }
                                }
                            });
                        }

                        function bindKeyup() {
                            $field
                                .off("keyup")
                                .keyup(function (event) {

                                    switch (event.keyCode) {

                                        case 27:

                                            hideContainer();
                                            loseFieldFocus();
                                            break;

                                        case 38:

                                            event.preventDefault();

                                            if (elementsList.length > 0 && selectedElement > 0) {

                                                selectedElement -= 1;

                                                $field.val(config.get("getValue")(elementsList[selectedElement]));

                                                selectElement(selectedElement);

                                            }
                                            break;

                                        case 40:

                                            event.preventDefault();

                                            if (elementsList.length > 0 && selectedElement < elementsList.length - 1) {

                                                selectedElement += 1;

                                                $field.val(config.get("getValue")(elementsList[selectedElement]));

                                                selectElement(selectedElement);

                                            }

                                            break;

                                        default:

                                            if (event.keyCode > 40 || event.keyCode === 8) {

                                                var inputPhrase = $field.val();

                                                if (!(config.get("list").hideOnEmptyPhrase === true && event.keyCode === 8 && inputPhrase === "")) {

                                                    if (config.get("requestDelay") > 0) {
                                                        if (requestDelayTimeoutId !== undefined) {
                                                            clearTimeout(requestDelayTimeoutId);
                                                        }

                                                        requestDelayTimeoutId = setTimeout(function () { loadData(inputPhrase); }, config.get("requestDelay"));
                                                    } else {
                                                        loadData(inputPhrase);
                                                    }

                                                } else {
                                                    hideContainer();
                                                }

                                            }


                                            break;
                                    }


                                    function loadData(inputPhrase) {


                                        if (inputPhrase.length < config.get("minCharNumber")) {
                                            return;
                                        }


                                        if (config.get("data") !== "list-required") {

                                            var data = config.get("data");

                                            var listBuilders = listBuilderService.init(data);

                                            listBuilders = listBuilderService.updateCategories(listBuilders, data);

                                            listBuilders = listBuilderService.processData(listBuilders, inputPhrase);

                                            loadElements(listBuilders, inputPhrase);

                                            if ($field.parent().find("li").length > 0) {
                                                showContainer();
                                            } else {
                                                hideContainer();
                                            }

                                        }

                                        var settings = createAjaxSettings();

                                        if (settings.url === undefined || settings.url === "") {
                                            settings.url = config.get("url");
                                        }

                                        if (settings.dataType === undefined || settings.dataType === "") {
                                            settings.dataType = config.get("dataType");
                                        }


                                        if (settings.url !== undefined && settings.url !== "list-required") {

                                            settings.url = settings.url(inputPhrase);

                                            settings.data = config.get("preparePostData")(settings.data, inputPhrase);

                                            $.ajax(settings)
                                                .done(function (data) {

                                                    var listBuilders = listBuilderService.init(data);

                                                    listBuilders = listBuilderService.updateCategories(listBuilders, data);

                                                    listBuilders = listBuilderService.convertXml(listBuilders);
                                                    if (checkInputPhraseMatchResponse(inputPhrase, data)) {

                                                        listBuilders = listBuilderService.processData(listBuilders, inputPhrase);

                                                        loadElements(listBuilders, inputPhrase);

                                                    }

                                                    if (listBuilderService.checkIfDataExists(listBuilders) && $field.parent().find("li").length > 0) {
                                                        showContainer();
                                                    } else {
                                                        hideContainer();
                                                    }

                                                    config.get("ajaxCallback")();

                                                })
                                                .fail(function () {
                                                    logger.warning("Fail to load response data");
                                                })
                                                .always(function () {

                                                });
                                        }



                                        function createAjaxSettings() {

                                            var settings = {},
                                                ajaxSettings = config.get("ajaxSettings") || {};

                                            for (var set in ajaxSettings) {
                                                settings[set] = ajaxSettings[set];
                                            }

                                            return settings;
                                        }

                                        function checkInputPhraseMatchResponse(inputPhrase, data) {

                                            if (config.get("matchResponseProperty") !== false) {
                                                if (typeof config.get("matchResponseProperty") === "string") {
                                                    return (data[config.get("matchResponseProperty")] === inputPhrase);
                                                }

                                                if (typeof config.get("matchResponseProperty") === "function") {
                                                    return (config.get("matchResponseProperty")(data) === inputPhrase);
                                                }

                                                return true;
                                            } else {
                                                return true;
                                            }

                                        }

                                    }


                                });
                        }

                        function bindKeydown() {
                            $field
                                .on("keydown", function (evt) {
                                    evt = evt || window.event;
                                    var keyCode = evt.keyCode;
                                    if (keyCode === 38) {
                                        suppressKeypress = true;
                                        return false;
                                    }
                                })
                                .keydown(function (event) {

                                    if (event.keyCode === 13 && selectedElement > -1) {

                                        $field.val(config.get("getValue")(elementsList[selectedElement]));

                                        config.get("list").onKeyEnterEvent();
                                        config.get("list").onChooseEvent();

                                        selectedElement = -1;
                                        hideContainer();

                                        event.preventDefault();
                                    }
                                });
                        }

                        function bindKeypress() {
                            $field
                                .off("keypress");
                        }

                        function bindFocus() {
                            $field.focus(function () {

                                if ($field.val() !== "" && elementsList.length > 0) {

                                    selectedElement = -1;
                                    showContainer();
                                }

                            });
                        }

                        function bindBlur() {
                            $field.blur(function () {
                                setTimeout(function () {

                                    selectedElement = -1;
                                    hideContainer();
                                }, 250);
                            });
                        }

                        function removeAutocomplete() {
                            $field.attr("autocomplete", "off");
                        }

                    }

                    function showContainer() {
                        $container.trigger("show.eac");
                    }

                    function hideContainer() {
                        $container.trigger("hide.eac");
                    }

                    function selectElement(index) {

                        $container.trigger("selectElement.eac", index);
                    }

                    function loadElements(list, phrase) {
                        $container.trigger("loadElements.eac", [list, phrase]);
                    }

                    function loseFieldFocus() {
                        $field.trigger("blur");
                    }


                };
                scope.eacHandles = [];

                scope.getHandle = function (id) {
                    return scope.eacHandles[id];
                };

                scope.inputHasId = function (input) {

                    if ($(input).attr("id") !== undefined && $(input).attr("id").length > 0) {
                        return true;
                    } else {
                        return false;
                    }

                };

                scope.assignRandomId = function (input) {

                    var fieldId = "";

                    do {
                        fieldId = "eac-" + Math.floor(Math.random() * 10000);
                    } while ($("#" + fieldId).length !== 0);

                    elementId = scope.consts.getValue("CONTAINER_ID") + fieldId;

                    $(input).attr("id", fieldId);

                };

                scope.setHandle = function (handle, id) {
                    scope.eacHandles[id] = handle;
                };


                return scope;

            })(EasyAutocomplete || {});

            (function ($) {

                $.fn.easyAutocomplete = function (options) {

                    return this.each(function () {
                        var $this = $(this),
                            eacHandle = new EasyAutocomplete.main($this, options);

                        if (!EasyAutocomplete.inputHasId($this)) {
                            EasyAutocomplete.assignRandomId($this);
                        }

                        eacHandle.init();

                        EasyAutocomplete.setHandle(eacHandle, $this.attr("id"));

                    });
                };

                $.fn.getSelectedItemIndex = function () {

                    var inputId = $(this).attr("id");

                    if (inputId !== undefined) {
                        return EasyAutocomplete.getHandle(inputId).getSelectedItemIndex();
                    }

                    return -1;
                };

                $.fn.getItems = function () {

                    var inputId = $(this).attr("id");

                    if (inputId !== undefined) {
                        return EasyAutocomplete.getHandle(inputId).getItems();
                    }

                    return -1;
                };

                $.fn.getItemData = function (index) {

                    var inputId = $(this).attr("id");

                    if (inputId !== undefined && index > -1) {
                        return EasyAutocomplete.getHandle(inputId).getItemData(index);
                    }

                    return -1;
                };

                $.fn.getSelectedItemData = function () {

                    var inputId = $(this).attr("id");

                    if (inputId !== undefined) {
                        return EasyAutocomplete.getHandle(inputId).getSelectedItemData();
                    }

                    return -1;
                };

            })(jQuery);

            /* WEBPACK VAR INJECTION */
        }.call(exports, __webpack_require__(0), __webpack_require__(0)))

        /***/
    }),
/* 101 */
/***/ (function (module, exports) {

        // removed by extract-text-webpack-plugin

        /***/
    }),
/* 102 */
/***/ (function (module, exports, __webpack_require__) {

        var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__; (function (root, factory) {

            if (root === null) {
                throw new Error('Google-maps package can be used only in browser');
            }

            if (true) {
                !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
                    __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
                        (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
                        __WEBPACK_AMD_DEFINE_FACTORY__),
                    __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
            } else if (typeof exports === 'object') {
                module.exports = factory();
            } else {
                root.GoogleMapsLoader = factory();
            }

        })(typeof window !== 'undefined' ? window : null, function () {


            'use strict';


            var googleVersion = '3.18';

            var script = null;

            var google = null;

            var loading = false;

            var callbacks = [];

            var onLoadEvents = [];

            var originalCreateLoaderMethod = null;


            var GoogleMapsLoader = {};


            GoogleMapsLoader.URL = 'https://maps.googleapis.com/maps/api/js';

            GoogleMapsLoader.KEY = null;

            GoogleMapsLoader.LIBRARIES = [];

            GoogleMapsLoader.CLIENT = null;

            GoogleMapsLoader.CHANNEL = null;

            GoogleMapsLoader.LANGUAGE = null;

            GoogleMapsLoader.REGION = null;

            GoogleMapsLoader.VERSION = googleVersion;

            GoogleMapsLoader.WINDOW_CALLBACK_NAME = '__google_maps_api_provider_initializator__';


            GoogleMapsLoader._googleMockApiObject = {};


            GoogleMapsLoader.load = function (fn) {
                if (google === null) {
                    if (loading === true) {
                        if (fn) {
                            callbacks.push(fn);
                        }
                    } else {
                        loading = true;

                        window[GoogleMapsLoader.WINDOW_CALLBACK_NAME] = function () {
                            ready(fn);
                        };

                        GoogleMapsLoader.createLoader();
                    }
                } else if (fn) {
                    fn(google);
                }
            };


            GoogleMapsLoader.createLoader = function () {
                script = document.createElement('script');
                script.type = 'text/javascript';
                script.src = GoogleMapsLoader.createUrl();

                document.body.appendChild(script);
            };


            GoogleMapsLoader.isLoaded = function () {
                return google !== null;
            };


            GoogleMapsLoader.createUrl = function () {
                var url = GoogleMapsLoader.URL;

                url += '?callback=' + GoogleMapsLoader.WINDOW_CALLBACK_NAME;

                if (GoogleMapsLoader.KEY) {
                    url += '&key=' + GoogleMapsLoader.KEY;
                }

                if (GoogleMapsLoader.LIBRARIES.length > 0) {
                    url += '&libraries=' + GoogleMapsLoader.LIBRARIES.join(',');
                }

                if (GoogleMapsLoader.CLIENT) {
                    url += '&client=' + GoogleMapsLoader.CLIENT + '&v=' + GoogleMapsLoader.VERSION;
                }

                if (GoogleMapsLoader.CHANNEL) {
                    url += '&channel=' + GoogleMapsLoader.CHANNEL;
                }

                if (GoogleMapsLoader.LANGUAGE) {
                    url += '&language=' + GoogleMapsLoader.LANGUAGE;
                }

                if (GoogleMapsLoader.REGION) {
                    url += '&region=' + GoogleMapsLoader.REGION;
                }

                return url;
            };


            GoogleMapsLoader.release = function (fn) {
                var release = function () {
                    GoogleMapsLoader.KEY = null;
                    GoogleMapsLoader.LIBRARIES = [];
                    GoogleMapsLoader.CLIENT = null;
                    GoogleMapsLoader.CHANNEL = null;
                    GoogleMapsLoader.LANGUAGE = null;
                    GoogleMapsLoader.REGION = null;
                    GoogleMapsLoader.VERSION = googleVersion;

                    google = null;
                    loading = false;
                    callbacks = [];
                    onLoadEvents = [];

                    if (typeof window.google !== 'undefined') {
                        delete window.google;
                    }

                    if (typeof window[GoogleMapsLoader.WINDOW_CALLBACK_NAME] !== 'undefined') {
                        delete window[GoogleMapsLoader.WINDOW_CALLBACK_NAME];
                    }

                    if (originalCreateLoaderMethod !== null) {
                        GoogleMapsLoader.createLoader = originalCreateLoaderMethod;
                        originalCreateLoaderMethod = null;
                    }

                    if (script !== null) {
                        script.parentElement.removeChild(script);
                        script = null;
                    }

                    if (fn) {
                        fn();
                    }
                };

                if (loading) {
                    GoogleMapsLoader.load(function () {
                        release();
                    });
                } else {
                    release();
                }
            };


            GoogleMapsLoader.onLoad = function (fn) {
                onLoadEvents.push(fn);
            };


            GoogleMapsLoader.makeMock = function () {
                originalCreateLoaderMethod = GoogleMapsLoader.createLoader;

                GoogleMapsLoader.createLoader = function () {
                    window.google = GoogleMapsLoader._googleMockApiObject;
                    window[GoogleMapsLoader.WINDOW_CALLBACK_NAME]();
                };
            };


            var ready = function (fn) {
                var i;

                loading = false;

                if (google === null) {
                    google = window.google;
                }

                for (i = 0; i < onLoadEvents.length; i++) {
                    onLoadEvents[i](google);
                }

                if (fn) {
                    fn(google);
                }

                for (i = 0; i < callbacks.length; i++) {
                    callbacks[i](google);
                }

                callbacks = [];
            };


            return GoogleMapsLoader;

        });


        /***/
    }),
/* 103 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";
        function createLi(t) { var e = document.createElement("li"), n = document.createTextNode(t.value); return e.appendChild(n), t.liClass && e.classList.add(t.liClass), t.title && e.setAttribute("title", t.title), e.addEventListener("click", function () { t.action(t.value) }), e } function createLists(t, e) { var n = document.createElement("ul"); n.classList.add(e.ulClass); for (var c = 0; c < t.length; c++)n.appendChild(createLi(t[c])); return n } function replaceElement(t, e) { e.parentNode.replaceChild(t, e) } function scrollToTop(t) { var e = 10; window.scrollTo(0, 0), Array.prototype.slice.call(document.querySelectorAll(t)).forEach(function (t) { var n = setInterval(function () { t.scrollTop <= 0 ? clearInterval(n) : (t.scrollTop -= e, e += 1) }, 10) }) } function noop() { } function validateCurrent(t, e) { e.current > t && (e.current = t), e.current <= 0 && (e.current = 1), t <= 1 && (e.hide = _config.hideIfEmpty) } function internalAction(t, e) { e.current !== t && (e.current = t, e.action({ current: e.current, size: e.size, total: e.total }), build(e), _config.scrollTop && scrollToTop(_config.scrollContainer)) } function createRange(t, e, n) { for (var c = function (t) { return { value: t, title: "cn" === _config.lang ? "第" + t + "页" : "Page " + t, liClass: n.current === t ? _config.activeClass : "", action: function (t) { internalAction(t, n) } } }, i = [], r = t; r <= e; r++) { var a = c(r); i.push(a) } return i } function createDots() { return [{ value: _config.dots, action: function () { } }] } function createFirst(t, e) { return createRange(1, 1, e).concat(createDots()) } function createLast(t, e) { return createDots().concat(createRange(t, t, e)) } function createPreNext(t, e, n) { if (!_config.showPreNext || t < 1) return []; var c, i; if ("pre" === n) { c = e.current - 1 <= 0; var r = e.current - 1 <= 0 ? 1 : e.current - 1; i = { value: "⟨", title: "cn" === _config.lang ? "上一页" : "Pre page", page: r } } else { c = e.current + 1 > t; var a = e.current + 1 >= t ? t : e.current + 1; i = { value: "⟩", title: "cn" === _config.lang ? "下一页" : "Next page", page: a } } return [function (t, n) { return { value: t.value, title: t.title, liClass: n ? _config.disableClass : "", action: function (c) { n || internalAction(t.page, e) } } }(i, c)] } function build(t) { t.lists = []; var e = Math.ceil(t.total / t.size), n = 2 * _config.adjacent + 3; if (validateCurrent(e, t), t.lists = t.lists.concat(createPreNext(e, t, "pre")), e <= n) t.lists = t.lists.concat(createRange(1, e, t)); else if (t.current - _config.adjacent <= 2) t.lists = t.lists.concat(createRange(1, n, t)), t.lists = t.lists.concat(createLast(e, t)); else if (t.current < e - (_config.adjacent + 2)) { var c = t.current - _config.adjacent, i = t.current + _config.adjacent; t.lists = t.lists.concat(createFirst(e, t)), t.lists = t.lists.concat(createRange(c, i, t)), t.lists = t.lists.concat(createLast(e, t)) } else { var r = e - n + 1, a = e; t.lists = t.lists.concat(createFirst(e, t)), t.lists = t.lists.concat(createRange(r, a, t)) } t.lists = t.lists.concat(createPreNext(e, t, "next")); var o = createLists(t.lists, _config); replaceElement(o, t.field), t.field = o, t.hide && (t.field.style.display = "none") } var _config = { ulClass: "pagination", dots: "...", activeClass: "active", disableClass: "disabled", hideIfEmpty: !0, showPreNext: !0, scrollTop: !1, scrollContainer: "body", adjacent: 2, lang: "cn" }, Pagination = function (t, e, n, c) { this.total = t || 1, this.size = e || 1, this.action = n || noop, this.field = document.querySelector(c), this.lists = [], this.current = 1, build(this) }; Pagination.config = function t(t) { Object.keys(t).forEach(function (e) { if (!_config.hasOwnProperty(e)) throw new Error("cannot set config key " + e + ", not exists!"); _config[e] = t[e] }) }, Pagination.prototype.goToPage = function (t) { t = Number(t), internalAction(t, this) }, Pagination.prototype.getCurrentPage = function () { return this.current }, module.exports = Pagination;

        /***/
    }),
/* 104 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        module.exports = __webpack_require__(107);


        /***/
    }),
/* 105 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var EventElement = function (element) {
            this.element = element;
            this.events = {};
        };

        EventElement.prototype.bind = function (eventName, handler) {
            if (typeof this.events[eventName] === 'undefined') {
                this.events[eventName] = [];
            }
            this.events[eventName].push(handler);
            this.element.addEventListener(eventName, handler, false);
        };

        EventElement.prototype.unbind = function (eventName, handler) {
            var isHandlerProvided = (typeof handler !== 'undefined');
            this.events[eventName] = this.events[eventName].filter(function (hdlr) {
                if (isHandlerProvided && hdlr !== handler) {
                    return true;
                }
                this.element.removeEventListener(eventName, hdlr, false);
                return false;
            }, this);
        };

        EventElement.prototype.unbindAll = function () {
            for (var name in this.events) {
                this.unbind(name);
            }
        };

        var EventManager = function () {
            this.eventElements = [];
        };

        EventManager.prototype.eventElement = function (element) {
            var ee = this.eventElements.filter(function (eventElement) {
                return eventElement.element === element;
            })[0];
            if (typeof ee === 'undefined') {
                ee = new EventElement(element);
                this.eventElements.push(ee);
            }
            return ee;
        };

        EventManager.prototype.bind = function (element, eventName, handler) {
            this.eventElement(element).bind(eventName, handler);
        };

        EventManager.prototype.unbind = function (element, eventName, handler) {
            this.eventElement(element).unbind(eventName, handler);
        };

        EventManager.prototype.unbindAll = function () {
            for (var i = 0; i < this.eventElements.length; i++) {
                this.eventElements[i].unbindAll();
            }
        };

        EventManager.prototype.once = function (element, eventName, handler) {
            var ee = this.eventElement(element);
            var onceHandler = function (e) {
                ee.unbind(eventName, onceHandler);
                handler(e);
            };
            ee.bind(eventName, onceHandler);
        };

        module.exports = EventManager;


        /***/
    }),
/* 106 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        module.exports = (function () {
            function s4() {
                return Math.floor((1 + Math.random()) * 0x10000)
                    .toString(16)
                    .substring(1);
            }
            return function () {
                return s4() + s4() + '-' + s4() + '-' + s4() + '-' +
                    s4() + '-' + s4() + s4() + s4();
            };
        })();


        /***/
    }),
/* 107 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var destroy = __webpack_require__(109);
        var initialize = __webpack_require__(117);
        var update = __webpack_require__(118);

        module.exports = {
            initialize: initialize,
            update: update,
            destroy: destroy
        };


        /***/
    }),
/* 108 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        module.exports = {
            handlers: ['click-rail', 'drag-scrollbar', 'keyboard', 'wheel', 'touch'],
            maxScrollbarLength: null,
            minScrollbarLength: null,
            scrollXMarginOffset: 0,
            scrollYMarginOffset: 0,
            suppressScrollX: false,
            suppressScrollY: false,
            swipePropagation: true,
            swipeEasing: true,
            useBothWheelAxes: false,
            wheelPropagation: false,
            wheelSpeed: 1,
            theme: 'default'
        };


        /***/
    }),
/* 109 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var dom = __webpack_require__(8);
        var instances = __webpack_require__(2);

        module.exports = function (element) {
            var i = instances.get(element);

            if (!i) {
                return;
            }

            i.event.unbindAll();
            dom.remove(i.scrollbarX);
            dom.remove(i.scrollbarY);
            dom.remove(i.scrollbarXRail);
            dom.remove(i.scrollbarYRail);
            _.removePsClasses(element);

            instances.remove(element);
        };


        /***/
    }),
/* 110 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);
        var updateScroll = __webpack_require__(7);

        function bindClickRailHandler(element, i) {
            function pageOffset(el) {
                return el.getBoundingClientRect();
            }
            var stopPropagation = function (e) { e.stopPropagation(); };

            i.event.bind(i.scrollbarY, 'click', stopPropagation);
            i.event.bind(i.scrollbarYRail, 'click', function (e) {
                var positionTop = e.pageY - window.pageYOffset - pageOffset(i.scrollbarYRail).top;
                var direction = positionTop > i.scrollbarYTop ? 1 : -1;

                updateScroll(element, 'top', element.scrollTop + direction * i.containerHeight);
                updateGeometry(element);

                e.stopPropagation();
            });

            i.event.bind(i.scrollbarX, 'click', stopPropagation);
            i.event.bind(i.scrollbarXRail, 'click', function (e) {
                var positionLeft = e.pageX - window.pageXOffset - pageOffset(i.scrollbarXRail).left;
                var direction = positionLeft > i.scrollbarXLeft ? 1 : -1;

                updateScroll(element, 'left', element.scrollLeft + direction * i.containerWidth);
                updateGeometry(element);

                e.stopPropagation();
            });
        }

        module.exports = function (element) {
            var i = instances.get(element);
            bindClickRailHandler(element, i);
        };


        /***/
    }),
/* 111 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var dom = __webpack_require__(8);
        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);
        var updateScroll = __webpack_require__(7);

        function bindMouseScrollXHandler(element, i) {
            var currentLeft = null;
            var currentPageX = null;

            function updateScrollLeft(deltaX) {
                var newLeft = currentLeft + (deltaX * i.railXRatio);
                var maxLeft = Math.max(0, i.scrollbarXRail.getBoundingClientRect().left) + (i.railXRatio * (i.railXWidth - i.scrollbarXWidth));

                if (newLeft < 0) {
                    i.scrollbarXLeft = 0;
                } else if (newLeft > maxLeft) {
                    i.scrollbarXLeft = maxLeft;
                } else {
                    i.scrollbarXLeft = newLeft;
                }

                var scrollLeft = _.toInt(i.scrollbarXLeft * (i.contentWidth - i.containerWidth) / (i.containerWidth - (i.railXRatio * i.scrollbarXWidth))) - i.negativeScrollAdjustment;
                updateScroll(element, 'left', scrollLeft);
            }

            var mouseMoveHandler = function (e) {
                updateScrollLeft(e.pageX - currentPageX);
                updateGeometry(element);
                e.stopPropagation();
                e.preventDefault();
            };

            var mouseUpHandler = function () {
                _.stopScrolling(element, 'x');
                i.event.unbind(i.ownerDocument, 'mousemove', mouseMoveHandler);
            };

            i.event.bind(i.scrollbarX, 'mousedown', function (e) {
                currentPageX = e.pageX;
                currentLeft = _.toInt(dom.css(i.scrollbarX, 'left')) * i.railXRatio;
                _.startScrolling(element, 'x');

                i.event.bind(i.ownerDocument, 'mousemove', mouseMoveHandler);
                i.event.once(i.ownerDocument, 'mouseup', mouseUpHandler);

                e.stopPropagation();
                e.preventDefault();
            });
        }

        function bindMouseScrollYHandler(element, i) {
            var currentTop = null;
            var currentPageY = null;

            function updateScrollTop(deltaY) {
                var newTop = currentTop + (deltaY * i.railYRatio);
                var maxTop = Math.max(0, i.scrollbarYRail.getBoundingClientRect().top) + (i.railYRatio * (i.railYHeight - i.scrollbarYHeight));

                if (newTop < 0) {
                    i.scrollbarYTop = 0;
                } else if (newTop > maxTop) {
                    i.scrollbarYTop = maxTop;
                } else {
                    i.scrollbarYTop = newTop;
                }

                var scrollTop = _.toInt(i.scrollbarYTop * (i.contentHeight - i.containerHeight) / (i.containerHeight - (i.railYRatio * i.scrollbarYHeight)));
                updateScroll(element, 'top', scrollTop);
            }

            var mouseMoveHandler = function (e) {
                updateScrollTop(e.pageY - currentPageY);
                updateGeometry(element);
                e.stopPropagation();
                e.preventDefault();
            };

            var mouseUpHandler = function () {
                _.stopScrolling(element, 'y');
                i.event.unbind(i.ownerDocument, 'mousemove', mouseMoveHandler);
            };

            i.event.bind(i.scrollbarY, 'mousedown', function (e) {
                currentPageY = e.pageY;
                currentTop = _.toInt(dom.css(i.scrollbarY, 'top')) * i.railYRatio;
                _.startScrolling(element, 'y');

                i.event.bind(i.ownerDocument, 'mousemove', mouseMoveHandler);
                i.event.once(i.ownerDocument, 'mouseup', mouseUpHandler);

                e.stopPropagation();
                e.preventDefault();
            });
        }

        module.exports = function (element) {
            var i = instances.get(element);
            bindMouseScrollXHandler(element, i);
            bindMouseScrollYHandler(element, i);
        };


        /***/
    }),
/* 112 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var dom = __webpack_require__(8);
        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);
        var updateScroll = __webpack_require__(7);

        function bindKeyboardHandler(element, i) {
            var hovered = false;
            i.event.bind(element, 'mouseenter', function () {
                hovered = true;
            });
            i.event.bind(element, 'mouseleave', function () {
                hovered = false;
            });

            var shouldPrevent = false;
            function shouldPreventDefault(deltaX, deltaY) {
                var scrollTop = element.scrollTop;
                if (deltaX === 0) {
                    if (!i.scrollbarYActive) {
                        return false;
                    }
                    if ((scrollTop === 0 && deltaY > 0) || (scrollTop >= i.contentHeight - i.containerHeight && deltaY < 0)) {
                        return !i.settings.wheelPropagation;
                    }
                }

                var scrollLeft = element.scrollLeft;
                if (deltaY === 0) {
                    if (!i.scrollbarXActive) {
                        return false;
                    }
                    if ((scrollLeft === 0 && deltaX < 0) || (scrollLeft >= i.contentWidth - i.containerWidth && deltaX > 0)) {
                        return !i.settings.wheelPropagation;
                    }
                }
                return true;
            }

            i.event.bind(i.ownerDocument, 'keydown', function (e) {
                if ((e.isDefaultPrevented && e.isDefaultPrevented()) || e.defaultPrevented) {
                    return;
                }

                var focused = dom.matches(i.scrollbarX, ':focus') ||
                    dom.matches(i.scrollbarY, ':focus');

                if (!hovered && !focused) {
                    return;
                }

                var activeElement = document.activeElement ? document.activeElement : i.ownerDocument.activeElement;
                if (activeElement) {
                    if (activeElement.tagName === 'IFRAME') {
                        activeElement = activeElement.contentDocument.activeElement;
                    } else {
                        // go deeper if element is a webcomponent
                        while (activeElement.shadowRoot) {
                            activeElement = activeElement.shadowRoot.activeElement;
                        }
                    }
                    if (_.isEditable(activeElement)) {
                        return;
                    }
                }

                var deltaX = 0;
                var deltaY = 0;

                switch (e.which) {
                    case 37: // left
                        if (e.metaKey) {
                            deltaX = -i.contentWidth;
                        } else if (e.altKey) {
                            deltaX = -i.containerWidth;
                        } else {
                            deltaX = -30;
                        }
                        break;
                    case 38: // up
                        if (e.metaKey) {
                            deltaY = i.contentHeight;
                        } else if (e.altKey) {
                            deltaY = i.containerHeight;
                        } else {
                            deltaY = 30;
                        }
                        break;
                    case 39: // right
                        if (e.metaKey) {
                            deltaX = i.contentWidth;
                        } else if (e.altKey) {
                            deltaX = i.containerWidth;
                        } else {
                            deltaX = 30;
                        }
                        break;
                    case 40: // down
                        if (e.metaKey) {
                            deltaY = -i.contentHeight;
                        } else if (e.altKey) {
                            deltaY = -i.containerHeight;
                        } else {
                            deltaY = -30;
                        }
                        break;
                    case 33: // page up
                        deltaY = 90;
                        break;
                    case 32: // space bar
                        if (e.shiftKey) {
                            deltaY = 90;
                        } else {
                            deltaY = -90;
                        }
                        break;
                    case 34: // page down
                        deltaY = -90;
                        break;
                    case 35: // end
                        if (e.ctrlKey) {
                            deltaY = -i.contentHeight;
                        } else {
                            deltaY = -i.containerHeight;
                        }
                        break;
                    case 36: // home
                        if (e.ctrlKey) {
                            deltaY = element.scrollTop;
                        } else {
                            deltaY = i.containerHeight;
                        }
                        break;
                    default:
                        return;
                }

                updateScroll(element, 'top', element.scrollTop - deltaY);
                updateScroll(element, 'left', element.scrollLeft + deltaX);
                updateGeometry(element);

                shouldPrevent = shouldPreventDefault(deltaX, deltaY);
                if (shouldPrevent) {
                    e.preventDefault();
                }
            });
        }

        module.exports = function (element) {
            var i = instances.get(element);
            bindKeyboardHandler(element, i);
        };


        /***/
    }),
/* 113 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);
        var updateScroll = __webpack_require__(7);

        function bindMouseWheelHandler(element, i) {
            var shouldPrevent = false;

            function shouldPreventDefault(deltaX, deltaY) {
                var scrollTop = element.scrollTop;
                if (deltaX === 0) {
                    if (!i.scrollbarYActive) {
                        return false;
                    }
                    if ((scrollTop === 0 && deltaY > 0) || (scrollTop >= i.contentHeight - i.containerHeight && deltaY < 0)) {
                        return !i.settings.wheelPropagation;
                    }
                }

                var scrollLeft = element.scrollLeft;
                if (deltaY === 0) {
                    if (!i.scrollbarXActive) {
                        return false;
                    }
                    if ((scrollLeft === 0 && deltaX < 0) || (scrollLeft >= i.contentWidth - i.containerWidth && deltaX > 0)) {
                        return !i.settings.wheelPropagation;
                    }
                }
                return true;
            }

            function getDeltaFromEvent(e) {
                var deltaX = e.deltaX;
                var deltaY = -1 * e.deltaY;

                if (typeof deltaX === "undefined" || typeof deltaY === "undefined") {
                    // OS X Safari
                    deltaX = -1 * e.wheelDeltaX / 6;
                    deltaY = e.wheelDeltaY / 6;
                }

                if (e.deltaMode && e.deltaMode === 1) {
                    // Firefox in deltaMode 1: Line scrolling
                    deltaX *= 10;
                    deltaY *= 10;
                }

                if (deltaX !== deltaX && deltaY !== deltaY/* NaN checks */) {
                    // IE in some mouse drivers
                    deltaX = 0;
                    deltaY = e.wheelDelta;
                }

                if (e.shiftKey) {
                    // reverse axis with shift key
                    return [-deltaY, -deltaX];
                }
                return [deltaX, deltaY];
            }

            function shouldBeConsumedByChild(deltaX, deltaY) {
                var child = element.querySelector('textarea:hover, select[multiple]:hover, .ps-child:hover');
                if (child) {
                    var style = window.getComputedStyle(child);
                    var overflow = [
                        style.overflow,
                        style.overflowX,
                        style.overflowY
                    ].join('');

                    if (!overflow.match(/(scroll|auto)/)) {
                        // if not scrollable
                        return false;
                    }

                    var maxScrollTop = child.scrollHeight - child.clientHeight;
                    if (maxScrollTop > 0) {
                        if (!(child.scrollTop === 0 && deltaY > 0) && !(child.scrollTop === maxScrollTop && deltaY < 0)) {
                            return true;
                        }
                    }
                    var maxScrollLeft = child.scrollLeft - child.clientWidth;
                    if (maxScrollLeft > 0) {
                        if (!(child.scrollLeft === 0 && deltaX < 0) && !(child.scrollLeft === maxScrollLeft && deltaX > 0)) {
                            return true;
                        }
                    }
                }
                return false;
            }

            function mousewheelHandler(e) {
                var delta = getDeltaFromEvent(e);

                var deltaX = delta[0];
                var deltaY = delta[1];

                if (shouldBeConsumedByChild(deltaX, deltaY)) {
                    return;
                }

                shouldPrevent = false;
                if (!i.settings.useBothWheelAxes) {
                    // deltaX will only be used for horizontal scrolling and deltaY will
                    // only be used for vertical scrolling - this is the default
                    updateScroll(element, 'top', element.scrollTop - (deltaY * i.settings.wheelSpeed));
                    updateScroll(element, 'left', element.scrollLeft + (deltaX * i.settings.wheelSpeed));
                } else if (i.scrollbarYActive && !i.scrollbarXActive) {
                    // only vertical scrollbar is active and useBothWheelAxes option is
                    // active, so let's scroll vertical bar using both mouse wheel axes
                    if (deltaY) {
                        updateScroll(element, 'top', element.scrollTop - (deltaY * i.settings.wheelSpeed));
                    } else {
                        updateScroll(element, 'top', element.scrollTop + (deltaX * i.settings.wheelSpeed));
                    }
                    shouldPrevent = true;
                } else if (i.scrollbarXActive && !i.scrollbarYActive) {
                    // useBothWheelAxes and only horizontal bar is active, so use both
                    // wheel axes for horizontal bar
                    if (deltaX) {
                        updateScroll(element, 'left', element.scrollLeft + (deltaX * i.settings.wheelSpeed));
                    } else {
                        updateScroll(element, 'left', element.scrollLeft - (deltaY * i.settings.wheelSpeed));
                    }
                    shouldPrevent = true;
                }

                updateGeometry(element);

                shouldPrevent = (shouldPrevent || shouldPreventDefault(deltaX, deltaY));
                if (shouldPrevent) {
                    e.stopPropagation();
                    e.preventDefault();
                }
            }

            if (typeof window.onwheel !== "undefined") {
                i.event.bind(element, 'wheel', mousewheelHandler);
            } else if (typeof window.onmousewheel !== "undefined") {
                i.event.bind(element, 'mousewheel', mousewheelHandler);
            }
        }

        module.exports = function (element) {
            var i = instances.get(element);
            bindMouseWheelHandler(element, i);
        };


        /***/
    }),
/* 114 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);

        function bindNativeScrollHandler(element, i) {
            i.event.bind(element, 'scroll', function () {
                updateGeometry(element);
            });
        }

        module.exports = function (element) {
            var i = instances.get(element);
            bindNativeScrollHandler(element, i);
        };


        /***/
    }),
/* 115 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);
        var updateScroll = __webpack_require__(7);

        function bindSelectionHandler(element, i) {
            function getRangeNode() {
                var selection = window.getSelection ? window.getSelection() :
                    document.getSelection ? document.getSelection() : '';
                if (selection.toString().length === 0) {
                    return null;
                } else {
                    return selection.getRangeAt(0).commonAncestorContainer;
                }
            }

            var scrollingLoop = null;
            var scrollDiff = { top: 0, left: 0 };
            function startScrolling() {
                if (!scrollingLoop) {
                    scrollingLoop = setInterval(function () {
                        if (!instances.get(element)) {
                            clearInterval(scrollingLoop);
                            return;
                        }

                        updateScroll(element, 'top', element.scrollTop + scrollDiff.top);
                        updateScroll(element, 'left', element.scrollLeft + scrollDiff.left);
                        updateGeometry(element);
                    }, 50); // every .1 sec
                }
            }
            function stopScrolling() {
                if (scrollingLoop) {
                    clearInterval(scrollingLoop);
                    scrollingLoop = null;
                }
                _.stopScrolling(element);
            }

            var isSelected = false;
            i.event.bind(i.ownerDocument, 'selectionchange', function () {
                if (element.contains(getRangeNode())) {
                    isSelected = true;
                } else {
                    isSelected = false;
                    stopScrolling();
                }
            });
            i.event.bind(window, 'mouseup', function () {
                if (isSelected) {
                    isSelected = false;
                    stopScrolling();
                }
            });
            i.event.bind(window, 'keyup', function () {
                if (isSelected) {
                    isSelected = false;
                    stopScrolling();
                }
            });

            i.event.bind(window, 'mousemove', function (e) {
                if (isSelected) {
                    var mousePosition = { x: e.pageX, y: e.pageY };
                    var containerGeometry = {
                        left: element.offsetLeft,
                        right: element.offsetLeft + element.offsetWidth,
                        top: element.offsetTop,
                        bottom: element.offsetTop + element.offsetHeight
                    };

                    if (mousePosition.x < containerGeometry.left + 3) {
                        scrollDiff.left = -5;
                        _.startScrolling(element, 'x');
                    } else if (mousePosition.x > containerGeometry.right - 3) {
                        scrollDiff.left = 5;
                        _.startScrolling(element, 'x');
                    } else {
                        scrollDiff.left = 0;
                    }

                    if (mousePosition.y < containerGeometry.top + 3) {
                        if (containerGeometry.top + 3 - mousePosition.y < 5) {
                            scrollDiff.top = -5;
                        } else {
                            scrollDiff.top = -20;
                        }
                        _.startScrolling(element, 'y');
                    } else if (mousePosition.y > containerGeometry.bottom - 3) {
                        if (mousePosition.y - containerGeometry.bottom + 3 < 5) {
                            scrollDiff.top = 5;
                        } else {
                            scrollDiff.top = 20;
                        }
                        _.startScrolling(element, 'y');
                    } else {
                        scrollDiff.top = 0;
                    }

                    if (scrollDiff.top === 0 && scrollDiff.left === 0) {
                        stopScrolling();
                    } else {
                        startScrolling();
                    }
                }
            });
        }

        module.exports = function (element) {
            var i = instances.get(element);
            bindSelectionHandler(element, i);
        };


        /***/
    }),
/* 116 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);
        var updateScroll = __webpack_require__(7);

        function bindTouchHandler(element, i, supportsTouch, supportsIePointer) {
            function shouldPreventDefault(deltaX, deltaY) {
                var scrollTop = element.scrollTop;
                var scrollLeft = element.scrollLeft;
                var magnitudeX = Math.abs(deltaX);
                var magnitudeY = Math.abs(deltaY);

                if (magnitudeY > magnitudeX) {
                    // user is perhaps trying to swipe up/down the page

                    if (((deltaY < 0) && (scrollTop === i.contentHeight - i.containerHeight)) ||
                        ((deltaY > 0) && (scrollTop === 0))) {
                        return !i.settings.swipePropagation;
                    }
                } else if (magnitudeX > magnitudeY) {
                    // user is perhaps trying to swipe left/right across the page

                    if (((deltaX < 0) && (scrollLeft === i.contentWidth - i.containerWidth)) ||
                        ((deltaX > 0) && (scrollLeft === 0))) {
                        return !i.settings.swipePropagation;
                    }
                }

                return true;
            }

            function applyTouchMove(differenceX, differenceY) {
                updateScroll(element, 'top', element.scrollTop - differenceY);
                updateScroll(element, 'left', element.scrollLeft - differenceX);

                updateGeometry(element);
            }

            var startOffset = {};
            var startTime = 0;
            var speed = {};
            var easingLoop = null;
            var inGlobalTouch = false;
            var inLocalTouch = false;

            function globalTouchStart() {
                inGlobalTouch = true;
            }
            function globalTouchEnd() {
                inGlobalTouch = false;
            }

            function getTouch(e) {
                if (e.targetTouches) {
                    return e.targetTouches[0];
                } else {
                    // Maybe IE pointer
                    return e;
                }
            }
            function shouldHandle(e) {
                if (e.targetTouches && e.targetTouches.length === 1) {
                    return true;
                }
                if (e.pointerType && e.pointerType !== 'mouse' && e.pointerType !== e.MSPOINTER_TYPE_MOUSE) {
                    return true;
                }
                return false;
            }
            function touchStart(e) {
                if (shouldHandle(e)) {
                    inLocalTouch = true;

                    var touch = getTouch(e);

                    startOffset.pageX = touch.pageX;
                    startOffset.pageY = touch.pageY;

                    startTime = (new Date()).getTime();

                    if (easingLoop !== null) {
                        clearInterval(easingLoop);
                    }

                    e.stopPropagation();
                }
            }
            function touchMove(e) {
                if (!inLocalTouch && i.settings.swipePropagation) {
                    touchStart(e);
                }
                if (!inGlobalTouch && inLocalTouch && shouldHandle(e)) {
                    var touch = getTouch(e);

                    var currentOffset = { pageX: touch.pageX, pageY: touch.pageY };

                    var differenceX = currentOffset.pageX - startOffset.pageX;
                    var differenceY = currentOffset.pageY - startOffset.pageY;

                    applyTouchMove(differenceX, differenceY);
                    startOffset = currentOffset;

                    var currentTime = (new Date()).getTime();

                    var timeGap = currentTime - startTime;
                    if (timeGap > 0) {
                        speed.x = differenceX / timeGap;
                        speed.y = differenceY / timeGap;
                        startTime = currentTime;
                    }

                    if (shouldPreventDefault(differenceX, differenceY)) {
                        e.stopPropagation();
                        e.preventDefault();
                    }
                }
            }
            function touchEnd() {
                if (!inGlobalTouch && inLocalTouch) {
                    inLocalTouch = false;

                    if (i.settings.swipeEasing) {
                        clearInterval(easingLoop);
                        easingLoop = setInterval(function () {
                            if (!instances.get(element)) {
                                clearInterval(easingLoop);
                                return;
                            }

                            if (!speed.x && !speed.y) {
                                clearInterval(easingLoop);
                                return;
                            }

                            if (Math.abs(speed.x) < 0.01 && Math.abs(speed.y) < 0.01) {
                                clearInterval(easingLoop);
                                return;
                            }

                            applyTouchMove(speed.x * 30, speed.y * 30);

                            speed.x *= 0.8;
                            speed.y *= 0.8;
                        }, 10);
                    }
                }
            }

            if (supportsTouch) {
                i.event.bind(window, 'touchstart', globalTouchStart);
                i.event.bind(window, 'touchend', globalTouchEnd);
                i.event.bind(element, 'touchstart', touchStart);
                i.event.bind(element, 'touchmove', touchMove);
                i.event.bind(element, 'touchend', touchEnd);
            } else if (supportsIePointer) {
                if (window.PointerEvent) {
                    i.event.bind(window, 'pointerdown', globalTouchStart);
                    i.event.bind(window, 'pointerup', globalTouchEnd);
                    i.event.bind(element, 'pointerdown', touchStart);
                    i.event.bind(element, 'pointermove', touchMove);
                    i.event.bind(element, 'pointerup', touchEnd);
                } else if (window.MSPointerEvent) {
                    i.event.bind(window, 'MSPointerDown', globalTouchStart);
                    i.event.bind(window, 'MSPointerUp', globalTouchEnd);
                    i.event.bind(element, 'MSPointerDown', touchStart);
                    i.event.bind(element, 'MSPointerMove', touchMove);
                    i.event.bind(element, 'MSPointerUp', touchEnd);
                }
            }
        }

        module.exports = function (element) {
            if (!_.env.supportsTouch && !_.env.supportsIePointer) {
                return;
            }

            var i = instances.get(element);
            bindTouchHandler(element, i, _.env.supportsTouch, _.env.supportsIePointer);
        };


        /***/
    }),
/* 117 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var cls = __webpack_require__(23);
        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);

        // Handlers
        var handlers = {
            'click-rail': __webpack_require__(110),
            'drag-scrollbar': __webpack_require__(111),
            'keyboard': __webpack_require__(112),
            'wheel': __webpack_require__(113),
            'touch': __webpack_require__(116),
            'selection': __webpack_require__(115)
        };
        var nativeScrollHandler = __webpack_require__(114);

        module.exports = function (element, userSettings) {
            userSettings = typeof userSettings === 'object' ? userSettings : {};

            cls.add(element, 'ps');

            // Create a plugin instance.
            var i = instances.add(element);

            i.settings = _.extend(i.settings, userSettings);
            cls.add(element, 'ps--theme_' + i.settings.theme);

            i.settings.handlers.forEach(function (handlerName) {
                handlers[handlerName](element);
            });

            nativeScrollHandler(element);

            updateGeometry(element);
        };


        /***/
    }),
/* 118 */
/***/ (function (module, exports, __webpack_require__) {

        "use strict";


        var _ = __webpack_require__(5);
        var dom = __webpack_require__(8);
        var instances = __webpack_require__(2);
        var updateGeometry = __webpack_require__(6);
        var updateScroll = __webpack_require__(7);

        module.exports = function (element) {
            var i = instances.get(element);

            if (!i) {
                return;
            }

            // Recalcuate negative scrollLeft adjustment
            i.negativeScrollAdjustment = i.isNegativeScroll ? element.scrollWidth - element.clientWidth : 0;

            // Recalculate rail margins
            dom.css(i.scrollbarXRail, 'display', 'block');
            dom.css(i.scrollbarYRail, 'display', 'block');
            i.railXMarginWidth = _.toInt(dom.css(i.scrollbarXRail, 'marginLeft')) + _.toInt(dom.css(i.scrollbarXRail, 'marginRight'));
            i.railYMarginHeight = _.toInt(dom.css(i.scrollbarYRail, 'marginTop')) + _.toInt(dom.css(i.scrollbarYRail, 'marginBottom'));

            // Hide scrollbars not to affect scrollWidth and scrollHeight
            dom.css(i.scrollbarXRail, 'display', 'none');
            dom.css(i.scrollbarYRail, 'display', 'none');

            updateGeometry(element);

            // Update top/left scroll to trigger events
            updateScroll(element, 'top', element.scrollTop);
            updateScroll(element, 'left', element.scrollLeft);

            dom.css(i.scrollbarXRail, 'display', '');
            dom.css(i.scrollbarYRail, 'display', '');
        };


        /***/
    }),
/* 119 */
/***/ (function (module, exports, __webpack_require__) {

        module.exports = __webpack_require__(48);


        /***/
    })
/******/]);






$(document).ready(function () {
    $('.proTimeline .owl-carousel').owlCarousel({
        loop: false,
        dots: false,
        nav: true,
        items: 6,
        margin: 0,

        responsive: {
            0: {
                items: 2,
            },
            724: {
                items: 3,
            },
            1024: {
                items: 4,
            },
            1440: {
                items: 5,
            }
        }
    });
    $(window).resize(function () {
        SetHeightMainDemoDiv();
    });
    SetHeightMainDemoDiv();
});


function SetHeightMainDemoDiv() {
    var mh = 0;
    $(".proTimeline .proTimeline-slide").each(function () {
        var h_block = $(this).children('.main-div').outerHeight(true);
        if (h_block > mh) {
            mh = h_block;
        };
    });
    var h_block = Math.round(mh);
    $('.proTimeline-slide').each(function () {
        $(this).children('.main-div').height(h_block);
        $(this).children('.demo-div').height(h_block);
    });
};
/**
 * Owl Carousel v2.3.4
 * Copyright 2013-2018 David Deutsch
 * Licensed under: SEE LICENSE IN https://github.com/OwlCarousel2/OwlCarousel2/blob/master/LICENSE
 */
!function(a,b,c,d){function e(b,c){this.settings=null,this.options=a.extend({},e.Defaults,c),this.$element=a(b),this._handlers={},this._plugins={},this._supress={},this._current=null,this._speed=null,this._coordinates=[],this._breakpoint=null,this._width=null,this._items=[],this._clones=[],this._mergers=[],this._widths=[],this._invalidated={},this._pipe=[],this._drag={time:null,target:null,pointer:null,stage:{start:null,current:null},direction:null},this._states={current:{},tags:{initializing:["busy"],animating:["busy"],dragging:["interacting"]}},a.each(["onResize","onThrottledResize"],a.proxy(function(b,c){this._handlers[c]=a.proxy(this[c],this)},this)),a.each(e.Plugins,a.proxy(function(a,b){this._plugins[a.charAt(0).toLowerCase()+a.slice(1)]=new b(this)},this)),a.each(e.Workers,a.proxy(function(b,c){this._pipe.push({filter:c.filter,run:a.proxy(c.run,this)})},this)),this.setup(),this.initialize()}e.Defaults={items:3,loop:!1,center:!1,rewind:!1,checkVisibility:!0,mouseDrag:!0,touchDrag:!0,pullDrag:!0,freeDrag:!1,margin:0,stagePadding:0,merge:!1,mergeFit:!0,autoWidth:!1,startPosition:0,rtl:!1,smartSpeed:250,fluidSpeed:!1,dragEndSpeed:!1,responsive:{},responsiveRefreshRate:200,responsiveBaseElement:b,fallbackEasing:"swing",slideTransition:"",info:!1,nestedItemSelector:!1,itemElement:"div",stageElement:"div",refreshClass:"owl-refresh",loadedClass:"owl-loaded",loadingClass:"owl-loading",rtlClass:"owl-rtl",responsiveClass:"owl-responsive",dragClass:"owl-drag",itemClass:"owl-item",stageClass:"owl-stage",stageOuterClass:"owl-stage-outer",grabClass:"owl-grab"},e.Width={Default:"default",Inner:"inner",Outer:"outer"},e.Type={Event:"event",State:"state"},e.Plugins={},e.Workers=[{filter:["width","settings"],run:function(){this._width=this.$element.width()}},{filter:["width","items","settings"],run:function(a){a.current=this._items&&this._items[this.relative(this._current)]}},{filter:["items","settings"],run:function(){this.$stage.children(".cloned").remove()}},{filter:["width","items","settings"],run:function(a){var b=this.settings.margin||"",c=!this.settings.autoWidth,d=this.settings.rtl,e={width:"auto","margin-left":d?b:"","margin-right":d?"":b};!c&&this.$stage.children().css(e),a.css=e}},{filter:["width","items","settings"],run:function(a){var b=(this.width()/this.settings.items).toFixed(3)-this.settings.margin,c=null,d=this._items.length,e=!this.settings.autoWidth,f=[];for(a.items={merge:!1,width:b};d--;)c=this._mergers[d],c=this.settings.mergeFit&&Math.min(c,this.settings.items)||c,a.items.merge=c>1||a.items.merge,f[d]=e?b*c:this._items[d].width();this._widths=f}},{filter:["items","settings"],run:function(){var b=[],c=this._items,d=this.settings,e=Math.max(2*d.items,4),f=2*Math.ceil(c.length/2),g=d.loop&&c.length?d.rewind?e:Math.max(e,f):0,h="",i="";for(g/=2;g>0;)b.push(this.normalize(b.length/2,!0)),h+=c[b[b.length-1]][0].outerHTML,b.push(this.normalize(c.length-1-(b.length-1)/2,!0)),i=c[b[b.length-1]][0].outerHTML+i,g-=1;this._clones=b,a(h).addClass("cloned").appendTo(this.$stage),a(i).addClass("cloned").prependTo(this.$stage)}},{filter:["width","items","settings"],run:function(){for(var a=this.settings.rtl?1:-1,b=this._clones.length+this._items.length,c=-1,d=0,e=0,f=[];++c<b;)d=f[c-1]||0,e=this._widths[this.relative(c)]+this.settings.margin,f.push(d+e*a);this._coordinates=f}},{filter:["width","items","settings"],run:function(){var a=this.settings.stagePadding,b=this._coordinates,c={width:Math.ceil(Math.abs(b[b.length-1]))+2*a,"padding-left":a||"","padding-right":a||""};this.$stage.css(c)}},{filter:["width","items","settings"],run:function(a){var b=this._coordinates.length,c=!this.settings.autoWidth,d=this.$stage.children();if(c&&a.items.merge)for(;b--;)a.css.width=this._widths[this.relative(b)],d.eq(b).css(a.css);else c&&(a.css.width=a.items.width,d.css(a.css))}},{filter:["items"],run:function(){this._coordinates.length<1&&this.$stage.removeAttr("style")}},{filter:["width","items","settings"],run:function(a){a.current=a.current?this.$stage.children().index(a.current):0,a.current=Math.max(this.minimum(),Math.min(this.maximum(),a.current)),this.reset(a.current)}},{filter:["position"],run:function(){this.animate(this.coordinates(this._current))}},{filter:["width","position","items","settings"],run:function(){var a,b,c,d,e=this.settings.rtl?1:-1,f=2*this.settings.stagePadding,g=this.coordinates(this.current())+f,h=g+this.width()*e,i=[];for(c=0,d=this._coordinates.length;c<d;c++)a=this._coordinates[c-1]||0,b=Math.abs(this._coordinates[c])+f*e,(this.op(a,"<=",g)&&this.op(a,">",h)||this.op(b,"<",g)&&this.op(b,">",h))&&i.push(c);this.$stage.children(".active").removeClass("active"),this.$stage.children(":eq("+i.join("), :eq(")+")").addClass("active"),this.$stage.children(".center").removeClass("center"),this.settings.center&&this.$stage.children().eq(this.current()).addClass("center")}}],e.prototype.initializeStage=function(){this.$stage=this.$element.find("."+this.settings.stageClass),this.$stage.length||(this.$element.addClass(this.options.loadingClass),this.$stage=a("<"+this.settings.stageElement+">",{class:this.settings.stageClass}).wrap(a("<div/>",{class:this.settings.stageOuterClass})),this.$element.append(this.$stage.parent()))},e.prototype.initializeItems=function(){var b=this.$element.find(".owl-item");if(b.length)return this._items=b.get().map(function(b){return a(b)}),this._mergers=this._items.map(function(){return 1}),void this.refresh();this.replace(this.$element.children().not(this.$stage.parent())),this.isVisible()?this.refresh():this.invalidate("width"),this.$element.removeClass(this.options.loadingClass).addClass(this.options.loadedClass)},e.prototype.initialize=function(){if(this.enter("initializing"),this.trigger("initialize"),this.$element.toggleClass(this.settings.rtlClass,this.settings.rtl),this.settings.autoWidth&&!this.is("pre-loading")){var a,b,c;a=this.$element.find("img"),b=this.settings.nestedItemSelector?"."+this.settings.nestedItemSelector:d,c=this.$element.children(b).width(),a.length&&c<=0&&this.preloadAutoWidthImages(a)}this.initializeStage(),this.initializeItems(),this.registerEventHandlers(),this.leave("initializing"),this.trigger("initialized")},e.prototype.isVisible=function(){return!this.settings.checkVisibility||this.$element.is(":visible")},e.prototype.setup=function(){var b=this.viewport(),c=this.options.responsive,d=-1,e=null;c?(a.each(c,function(a){a<=b&&a>d&&(d=Number(a))}),e=a.extend({},this.options,c[d]),"function"==typeof e.stagePadding&&(e.stagePadding=e.stagePadding()),delete e.responsive,e.responsiveClass&&this.$element.attr("class",this.$element.attr("class").replace(new RegExp("("+this.options.responsiveClass+"-)\\S+\\s","g"),"$1"+d))):e=a.extend({},this.options),this.trigger("change",{property:{name:"settings",value:e}}),this._breakpoint=d,this.settings=e,this.invalidate("settings"),this.trigger("changed",{property:{name:"settings",value:this.settings}})},e.prototype.optionsLogic=function(){this.settings.autoWidth&&(this.settings.stagePadding=!1,this.settings.merge=!1)},e.prototype.prepare=function(b){var c=this.trigger("prepare",{content:b});return c.data||(c.data=a("<"+this.settings.itemElement+"/>").addClass(this.options.itemClass).append(b)),this.trigger("prepared",{content:c.data}),c.data},e.prototype.update=function(){for(var b=0,c=this._pipe.length,d=a.proxy(function(a){return this[a]},this._invalidated),e={};b<c;)(this._invalidated.all||a.grep(this._pipe[b].filter,d).length>0)&&this._pipe[b].run(e),b++;this._invalidated={},!this.is("valid")&&this.enter("valid")},e.prototype.width=function(a){switch(a=a||e.Width.Default){case e.Width.Inner:case e.Width.Outer:return this._width;default:return this._width-2*this.settings.stagePadding+this.settings.margin}},e.prototype.refresh=function(){this.enter("refreshing"),this.trigger("refresh"),this.setup(),this.optionsLogic(),this.$element.addClass(this.options.refreshClass),this.update(),this.$element.removeClass(this.options.refreshClass),this.leave("refreshing"),this.trigger("refreshed")},e.prototype.onThrottledResize=function(){b.clearTimeout(this.resizeTimer),this.resizeTimer=b.setTimeout(this._handlers.onResize,this.settings.responsiveRefreshRate)},e.prototype.onResize=function(){return!!this._items.length&&(this._width!==this.$element.width()&&(!!this.isVisible()&&(this.enter("resizing"),this.trigger("resize").isDefaultPrevented()?(this.leave("resizing"),!1):(this.invalidate("width"),this.refresh(),this.leave("resizing"),void this.trigger("resized")))))},e.prototype.registerEventHandlers=function(){a.support.transition&&this.$stage.on(a.support.transition.end+".owl.core",a.proxy(this.onTransitionEnd,this)),!1!==this.settings.responsive&&this.on(b,"resize",this._handlers.onThrottledResize),this.settings.mouseDrag&&(this.$element.addClass(this.options.dragClass),this.$stage.on("mousedown.owl.core",a.proxy(this.onDragStart,this)),this.$stage.on("dragstart.owl.core selectstart.owl.core",function(){return!1})),this.settings.touchDrag&&(this.$stage.on("touchstart.owl.core",a.proxy(this.onDragStart,this)),this.$stage.on("touchcancel.owl.core",a.proxy(this.onDragEnd,this)))},e.prototype.onDragStart=function(b){var d=null;3!==b.which&&(a.support.transform?(d=this.$stage.css("transform").replace(/.*\(|\)| /g,"").split(","),d={x:d[16===d.length?12:4],y:d[16===d.length?13:5]}):(d=this.$stage.position(),d={x:this.settings.rtl?d.left+this.$stage.width()-this.width()+this.settings.margin:d.left,y:d.top}),this.is("animating")&&(a.support.transform?this.animate(d.x):this.$stage.stop(),this.invalidate("position")),this.$element.toggleClass(this.options.grabClass,"mousedown"===b.type),this.speed(0),this._drag.time=(new Date).getTime(),this._drag.target=a(b.target),this._drag.stage.start=d,this._drag.stage.current=d,this._drag.pointer=this.pointer(b),a(c).on("mouseup.owl.core touchend.owl.core",a.proxy(this.onDragEnd,this)),a(c).one("mousemove.owl.core touchmove.owl.core",a.proxy(function(b){var d=this.difference(this._drag.pointer,this.pointer(b));a(c).on("mousemove.owl.core touchmove.owl.core",a.proxy(this.onDragMove,this)),Math.abs(d.x)<Math.abs(d.y)&&this.is("valid")||(b.preventDefault(),this.enter("dragging"),this.trigger("drag"))},this)))},e.prototype.onDragMove=function(a){var b=null,c=null,d=null,e=this.difference(this._drag.pointer,this.pointer(a)),f=this.difference(this._drag.stage.start,e);this.is("dragging")&&(a.preventDefault(),this.settings.loop?(b=this.coordinates(this.minimum()),c=this.coordinates(this.maximum()+1)-b,f.x=((f.x-b)%c+c)%c+b):(b=this.settings.rtl?this.coordinates(this.maximum()):this.coordinates(this.minimum()),c=this.settings.rtl?this.coordinates(this.minimum()):this.coordinates(this.maximum()),d=this.settings.pullDrag?-1*e.x/5:0,f.x=Math.max(Math.min(f.x,b+d),c+d)),this._drag.stage.current=f,this.animate(f.x))},e.prototype.onDragEnd=function(b){var d=this.difference(this._drag.pointer,this.pointer(b)),e=this._drag.stage.current,f=d.x>0^this.settings.rtl?"left":"right";a(c).off(".owl.core"),this.$element.removeClass(this.options.grabClass),(0!==d.x&&this.is("dragging")||!this.is("valid"))&&(this.speed(this.settings.dragEndSpeed||this.settings.smartSpeed),this.current(this.closest(e.x,0!==d.x?f:this._drag.direction)),this.invalidate("position"),this.update(),this._drag.direction=f,(Math.abs(d.x)>3||(new Date).getTime()-this._drag.time>300)&&this._drag.target.one("click.owl.core",function(){return!1})),this.is("dragging")&&(this.leave("dragging"),this.trigger("dragged"))},e.prototype.closest=function(b,c){var e=-1,f=30,g=this.width(),h=this.coordinates();return this.settings.freeDrag||a.each(h,a.proxy(function(a,i){return"left"===c&&b>i-f&&b<i+f?e=a:"right"===c&&b>i-g-f&&b<i-g+f?e=a+1:this.op(b,"<",i)&&this.op(b,">",h[a+1]!==d?h[a+1]:i-g)&&(e="left"===c?a+1:a),-1===e},this)),this.settings.loop||(this.op(b,">",h[this.minimum()])?e=b=this.minimum():this.op(b,"<",h[this.maximum()])&&(e=b=this.maximum())),e},e.prototype.animate=function(b){var c=this.speed()>0;this.is("animating")&&this.onTransitionEnd(),c&&(this.enter("animating"),this.trigger("translate")),a.support.transform3d&&a.support.transition?this.$stage.css({transform:"translate3d("+b+"px,0px,0px)",transition:this.speed()/1e3+"s"+(this.settings.slideTransition?" "+this.settings.slideTransition:"")}):c?this.$stage.animate({left:b+"px"},this.speed(),this.settings.fallbackEasing,a.proxy(this.onTransitionEnd,this)):this.$stage.css({left:b+"px"})},e.prototype.is=function(a){return this._states.current[a]&&this._states.current[a]>0},e.prototype.current=function(a){if(a===d)return this._current;if(0===this._items.length)return d;if(a=this.normalize(a),this._current!==a){var b=this.trigger("change",{property:{name:"position",value:a}});b.data!==d&&(a=this.normalize(b.data)),this._current=a,this.invalidate("position"),this.trigger("changed",{property:{name:"position",value:this._current}})}return this._current},e.prototype.invalidate=function(b){return"string"===a.type(b)&&(this._invalidated[b]=!0,this.is("valid")&&this.leave("valid")),a.map(this._invalidated,function(a,b){return b})},e.prototype.reset=function(a){(a=this.normalize(a))!==d&&(this._speed=0,this._current=a,this.suppress(["translate","translated"]),this.animate(this.coordinates(a)),this.release(["translate","translated"]))},e.prototype.normalize=function(a,b){var c=this._items.length,e=b?0:this._clones.length;return!this.isNumeric(a)||c<1?a=d:(a<0||a>=c+e)&&(a=((a-e/2)%c+c)%c+e/2),a},e.prototype.relative=function(a){return a-=this._clones.length/2,this.normalize(a,!0)},e.prototype.maximum=function(a){var b,c,d,e=this.settings,f=this._coordinates.length;if(e.loop)f=this._clones.length/2+this._items.length-1;else if(e.autoWidth||e.merge){if(b=this._items.length)for(c=this._items[--b].width(),d=this.$element.width();b--&&!((c+=this._items[b].width()+this.settings.margin)>d););f=b+1}else f=e.center?this._items.length-1:this._items.length-e.items;return a&&(f-=this._clones.length/2),Math.max(f,0)},e.prototype.minimum=function(a){return a?0:this._clones.length/2},e.prototype.items=function(a){return a===d?this._items.slice():(a=this.normalize(a,!0),this._items[a])},e.prototype.mergers=function(a){return a===d?this._mergers.slice():(a=this.normalize(a,!0),this._mergers[a])},e.prototype.clones=function(b){var c=this._clones.length/2,e=c+this._items.length,f=function(a){return a%2==0?e+a/2:c-(a+1)/2};return b===d?a.map(this._clones,function(a,b){return f(b)}):a.map(this._clones,function(a,c){return a===b?f(c):null})},e.prototype.speed=function(a){return a!==d&&(this._speed=a),this._speed},e.prototype.coordinates=function(b){var c,e=1,f=b-1;return b===d?a.map(this._coordinates,a.proxy(function(a,b){return this.coordinates(b)},this)):(this.settings.center?(this.settings.rtl&&(e=-1,f=b+1),c=this._coordinates[b],c+=(this.width()-c+(this._coordinates[f]||0))/2*e):c=this._coordinates[f]||0,c=Math.ceil(c))},e.prototype.duration=function(a,b,c){return 0===c?0:Math.min(Math.max(Math.abs(b-a),1),6)*Math.abs(c||this.settings.smartSpeed)},e.prototype.to=function(a,b){var c=this.current(),d=null,e=a-this.relative(c),f=(e>0)-(e<0),g=this._items.length,h=this.minimum(),i=this.maximum();this.settings.loop?(!this.settings.rewind&&Math.abs(e)>g/2&&(e+=-1*f*g),a=c+e,(d=((a-h)%g+g)%g+h)!==a&&d-e<=i&&d-e>0&&(c=d-e,a=d,this.reset(c))):this.settings.rewind?(i+=1,a=(a%i+i)%i):a=Math.max(h,Math.min(i,a)),this.speed(this.duration(c,a,b)),this.current(a),this.isVisible()&&this.update()},e.prototype.next=function(a){a=a||!1,this.to(this.relative(this.current())+1,a)},e.prototype.prev=function(a){a=a||!1,this.to(this.relative(this.current())-1,a)},e.prototype.onTransitionEnd=function(a){if(a!==d&&(a.stopPropagation(),(a.target||a.srcElement||a.originalTarget)!==this.$stage.get(0)))return!1;this.leave("animating"),this.trigger("translated")},e.prototype.viewport=function(){var d;return this.options.responsiveBaseElement!==b?d=a(this.options.responsiveBaseElement).width():b.innerWidth?d=b.innerWidth:c.documentElement&&c.documentElement.clientWidth?d=c.documentElement.clientWidth:console.warn("Can not detect viewport width."),d},e.prototype.replace=function(b){this.$stage.empty(),this._items=[],b&&(b=b instanceof jQuery?b:a(b)),this.settings.nestedItemSelector&&(b=b.find("."+this.settings.nestedItemSelector)),b.filter(function(){return 1===this.nodeType}).each(a.proxy(function(a,b){b=this.prepare(b),this.$stage.append(b),this._items.push(b),this._mergers.push(1*b.find("[data-merge]").addBack("[data-merge]").attr("data-merge")||1)},this)),this.reset(this.isNumeric(this.settings.startPosition)?this.settings.startPosition:0),this.invalidate("items")},e.prototype.add=function(b,c){var e=this.relative(this._current);c=c===d?this._items.length:this.normalize(c,!0),b=b instanceof jQuery?b:a(b),this.trigger("add",{content:b,position:c}),b=this.prepare(b),0===this._items.length||c===this._items.length?(0===this._items.length&&this.$stage.append(b),0!==this._items.length&&this._items[c-1].after(b),this._items.push(b),this._mergers.push(1*b.find("[data-merge]").addBack("[data-merge]").attr("data-merge")||1)):(this._items[c].before(b),this._items.splice(c,0,b),this._mergers.splice(c,0,1*b.find("[data-merge]").addBack("[data-merge]").attr("data-merge")||1)),this._items[e]&&this.reset(this._items[e].index()),this.invalidate("items"),this.trigger("added",{content:b,position:c})},e.prototype.remove=function(a){(a=this.normalize(a,!0))!==d&&(this.trigger("remove",{content:this._items[a],position:a}),this._items[a].remove(),this._items.splice(a,1),this._mergers.splice(a,1),this.invalidate("items"),this.trigger("removed",{content:null,position:a}))},e.prototype.preloadAutoWidthImages=function(b){b.each(a.proxy(function(b,c){this.enter("pre-loading"),c=a(c),a(new Image).one("load",a.proxy(function(a){c.attr("src",a.target.src),c.css("opacity",1),this.leave("pre-loading"),!this.is("pre-loading")&&!this.is("initializing")&&this.refresh()},this)).attr("src",c.attr("src")||c.attr("data-src")||c.attr("data-src-retina"))},this))},e.prototype.destroy=function(){this.$element.off(".owl.core"),this.$stage.off(".owl.core"),a(c).off(".owl.core"),!1!==this.settings.responsive&&(b.clearTimeout(this.resizeTimer),this.off(b,"resize",this._handlers.onThrottledResize));for(var d in this._plugins)this._plugins[d].destroy();this.$stage.children(".cloned").remove(),this.$stage.unwrap(),this.$stage.children().contents().unwrap(),this.$stage.children().unwrap(),this.$stage.remove(),this.$element.removeClass(this.options.refreshClass).removeClass(this.options.loadingClass).removeClass(this.options.loadedClass).removeClass(this.options.rtlClass).removeClass(this.options.dragClass).removeClass(this.options.grabClass).attr("class",this.$element.attr("class").replace(new RegExp(this.options.responsiveClass+"-\\S+\\s","g"),"")).removeData("owl.carousel")},e.prototype.op=function(a,b,c){var d=this.settings.rtl;switch(b){case"<":return d?a>c:a<c;case">":return d?a<c:a>c;case">=":return d?a<=c:a>=c;case"<=":return d?a>=c:a<=c}},e.prototype.on=function(a,b,c,d){a.addEventListener?a.addEventListener(b,c,d):a.attachEvent&&a.attachEvent("on"+b,c)},e.prototype.off=function(a,b,c,d){a.removeEventListener?a.removeEventListener(b,c,d):a.detachEvent&&a.detachEvent("on"+b,c)},e.prototype.trigger=function(b,c,d,f,g){var h={item:{count:this._items.length,index:this.current()}},i=a.camelCase(a.grep(["on",b,d],function(a){return a}).join("-").toLowerCase()),j=a.Event([b,"owl",d||"carousel"].join(".").toLowerCase(),a.extend({relatedTarget:this},h,c));return this._supress[b]||(a.each(this._plugins,function(a,b){b.onTrigger&&b.onTrigger(j)}),this.register({type:e.Type.Event,name:b}),this.$element.trigger(j),this.settings&&"function"==typeof this.settings[i]&&this.settings[i].call(this,j)),j},e.prototype.enter=function(b){a.each([b].concat(this._states.tags[b]||[]),a.proxy(function(a,b){this._states.current[b]===d&&(this._states.current[b]=0),this._states.current[b]++},this))},e.prototype.leave=function(b){a.each([b].concat(this._states.tags[b]||[]),a.proxy(function(a,b){this._states.current[b]--},this))},e.prototype.register=function(b){if(b.type===e.Type.Event){if(a.event.special[b.name]||(a.event.special[b.name]={}),!a.event.special[b.name].owl){var c=a.event.special[b.name]._default;a.event.special[b.name]._default=function(a){return!c||!c.apply||a.namespace&&-1!==a.namespace.indexOf("owl")?a.namespace&&a.namespace.indexOf("owl")>-1:c.apply(this,arguments)},a.event.special[b.name].owl=!0}}else b.type===e.Type.State&&(this._states.tags[b.name]?this._states.tags[b.name]=this._states.tags[b.name].concat(b.tags):this._states.tags[b.name]=b.tags,this._states.tags[b.name]=a.grep(this._states.tags[b.name],a.proxy(function(c,d){return a.inArray(c,this._states.tags[b.name])===d},this)))},e.prototype.suppress=function(b){a.each(b,a.proxy(function(a,b){this._supress[b]=!0},this))},e.prototype.release=function(b){a.each(b,a.proxy(function(a,b){delete this._supress[b]},this))},e.prototype.pointer=function(a){var c={x:null,y:null};return a=a.originalEvent||a||b.event,a=a.touches&&a.touches.length?a.touches[0]:a.changedTouches&&a.changedTouches.length?a.changedTouches[0]:a,a.pageX?(c.x=a.pageX,c.y=a.pageY):(c.x=a.clientX,c.y=a.clientY),c},e.prototype.isNumeric=function(a){return!isNaN(parseFloat(a))},e.prototype.difference=function(a,b){return{x:a.x-b.x,y:a.y-b.y}},a.fn.owlCarousel=function(b){var c=Array.prototype.slice.call(arguments,1);return this.each(function(){var d=a(this),f=d.data("owl.carousel");f||(f=new e(this,"object"==typeof b&&b),d.data("owl.carousel",f),a.each(["next","prev","to","destroy","refresh","replace","add","remove"],function(b,c){f.register({type:e.Type.Event,name:c}),f.$element.on(c+".owl.carousel.core",a.proxy(function(a){a.namespace&&a.relatedTarget!==this&&(this.suppress([c]),f[c].apply(this,[].slice.call(arguments,1)),this.release([c]))},f))})),"string"==typeof b&&"_"!==b.charAt(0)&&f[b].apply(f,c)})},a.fn.owlCarousel.Constructor=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){var e=function(b){this._core=b,this._interval=null,this._visible=null,this._handlers={"initialized.owl.carousel":a.proxy(function(a){a.namespace&&this._core.settings.autoRefresh&&this.watch()},this)},this._core.options=a.extend({},e.Defaults,this._core.options),this._core.$element.on(this._handlers)};e.Defaults={autoRefresh:!0,autoRefreshInterval:500},e.prototype.watch=function(){this._interval||(this._visible=this._core.isVisible(),this._interval=b.setInterval(a.proxy(this.refresh,this),this._core.settings.autoRefreshInterval))},e.prototype.refresh=function(){this._core.isVisible()!==this._visible&&(this._visible=!this._visible,this._core.$element.toggleClass("owl-hidden",!this._visible),this._visible&&this._core.invalidate("width")&&this._core.refresh())},e.prototype.destroy=function(){var a,c;b.clearInterval(this._interval);for(a in this._handlers)this._core.$element.off(a,this._handlers[a]);for(c in Object.getOwnPropertyNames(this))"function"!=typeof this[c]&&(this[c]=null)},a.fn.owlCarousel.Constructor.Plugins.AutoRefresh=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){var e=function(b){this._core=b,this._loaded=[],this._handlers={"initialized.owl.carousel change.owl.carousel resized.owl.carousel":a.proxy(function(b){if(b.namespace&&this._core.settings&&this._core.settings.lazyLoad&&(b.property&&"position"==b.property.name||"initialized"==b.type)){var c=this._core.settings,e=c.center&&Math.ceil(c.items/2)||c.items,f=c.center&&-1*e||0,g=(b.property&&b.property.value!==d?b.property.value:this._core.current())+f,h=this._core.clones().length,i=a.proxy(function(a,b){this.load(b)},this);for(c.lazyLoadEager>0&&(e+=c.lazyLoadEager,c.loop&&(g-=c.lazyLoadEager,e++));f++<e;)this.load(h/2+this._core.relative(g)),h&&a.each(this._core.clones(this._core.relative(g)),i),g++}},this)},this._core.options=a.extend({},e.Defaults,this._core.options),this._core.$element.on(this._handlers)};e.Defaults={lazyLoad:!1,lazyLoadEager:0},e.prototype.load=function(c){var d=this._core.$stage.children().eq(c),e=d&&d.find(".owl-lazy");!e||a.inArray(d.get(0),this._loaded)>-1||(e.each(a.proxy(function(c,d){var e,f=a(d),g=b.devicePixelRatio>1&&f.attr("data-src-retina")||f.attr("data-src")||f.attr("data-srcset");this._core.trigger("load",{element:f,url:g},"lazy"),f.is("img")?f.one("load.owl.lazy",a.proxy(function(){f.css("opacity",1),this._core.trigger("loaded",{element:f,url:g},"lazy")},this)).attr("src",g):f.is("source")?f.one("load.owl.lazy",a.proxy(function(){this._core.trigger("loaded",{element:f,url:g},"lazy")},this)).attr("srcset",g):(e=new Image,e.onload=a.proxy(function(){f.css({"background-image":'url("'+g+'")',opacity:"1"}),this._core.trigger("loaded",{element:f,url:g},"lazy")},this),e.src=g)},this)),this._loaded.push(d.get(0)))},e.prototype.destroy=function(){var a,b;for(a in this.handlers)this._core.$element.off(a,this.handlers[a]);for(b in Object.getOwnPropertyNames(this))"function"!=typeof this[b]&&(this[b]=null)},a.fn.owlCarousel.Constructor.Plugins.Lazy=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){var e=function(c){this._core=c,this._previousHeight=null,this._handlers={"initialized.owl.carousel refreshed.owl.carousel":a.proxy(function(a){a.namespace&&this._core.settings.autoHeight&&this.update()},this),"changed.owl.carousel":a.proxy(function(a){a.namespace&&this._core.settings.autoHeight&&"position"===a.property.name&&this.update()},this),"loaded.owl.lazy":a.proxy(function(a){a.namespace&&this._core.settings.autoHeight&&a.element.closest("."+this._core.settings.itemClass).index()===this._core.current()&&this.update()},this)},this._core.options=a.extend({},e.Defaults,this._core.options),this._core.$element.on(this._handlers),this._intervalId=null;var d=this;a(b).on("load",function(){d._core.settings.autoHeight&&d.update()}),a(b).resize(function(){d._core.settings.autoHeight&&(null!=d._intervalId&&clearTimeout(d._intervalId),d._intervalId=setTimeout(function(){d.update()},250))})};e.Defaults={autoHeight:!1,autoHeightClass:"owl-height"},e.prototype.update=function(){var b=this._core._current,c=b+this._core.settings.items,d=this._core.settings.lazyLoad,e=this._core.$stage.children().toArray().slice(b,c),f=[],g=0;a.each(e,function(b,c){f.push(a(c).height())}),g=Math.max.apply(null,f),g<=1&&d&&this._previousHeight&&(g=this._previousHeight),this._previousHeight=g,this._core.$stage.parent().height(g).addClass(this._core.settings.autoHeightClass)},e.prototype.destroy=function(){var a,b;for(a in this._handlers)this._core.$element.off(a,this._handlers[a]);for(b in Object.getOwnPropertyNames(this))"function"!=typeof this[b]&&(this[b]=null)},a.fn.owlCarousel.Constructor.Plugins.AutoHeight=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){var e=function(b){this._core=b,this._videos={},this._playing=null,this._handlers={"initialized.owl.carousel":a.proxy(function(a){a.namespace&&this._core.register({type:"state",name:"playing",tags:["interacting"]})},this),"resize.owl.carousel":a.proxy(function(a){a.namespace&&this._core.settings.video&&this.isInFullScreen()&&a.preventDefault()},this),"refreshed.owl.carousel":a.proxy(function(a){a.namespace&&this._core.is("resizing")&&this._core.$stage.find(".cloned .owl-video-frame").remove()},this),"changed.owl.carousel":a.proxy(function(a){a.namespace&&"position"===a.property.name&&this._playing&&this.stop()},this),"prepared.owl.carousel":a.proxy(function(b){if(b.namespace){var c=a(b.content).find(".owl-video");c.length&&(c.css("display","none"),this.fetch(c,a(b.content)))}},this)},this._core.options=a.extend({},e.Defaults,this._core.options),this._core.$element.on(this._handlers),this._core.$element.on("click.owl.video",".owl-video-play-icon",a.proxy(function(a){this.play(a)},this))};e.Defaults={video:!1,videoHeight:!1,videoWidth:!1},e.prototype.fetch=function(a,b){var c=function(){return a.attr("data-vimeo-id")?"vimeo":a.attr("data-vzaar-id")?"vzaar":"youtube"}(),d=a.attr("data-vimeo-id")||a.attr("data-youtube-id")||a.attr("data-vzaar-id"),e=a.attr("data-width")||this._core.settings.videoWidth,f=a.attr("data-height")||this._core.settings.videoHeight,g=a.attr("href");if(!g)throw new Error("Missing video URL.");if(d=g.match(/(http:|https:|)\/\/(player.|www.|app.)?(vimeo\.com|youtu(be\.com|\.be|be\.googleapis\.com|be\-nocookie\.com)|vzaar\.com)\/(video\/|videos\/|embed\/|channels\/.+\/|groups\/.+\/|watch\?v=|v\/)?([A-Za-z0-9._%-]*)(\&\S+)?/),d[3].indexOf("youtu")>-1)c="youtube";else if(d[3].indexOf("vimeo")>-1)c="vimeo";else{if(!(d[3].indexOf("vzaar")>-1))throw new Error("Video URL not supported.");c="vzaar"}d=d[6],this._videos[g]={type:c,id:d,width:e,height:f},b.attr("data-video",g),this.thumbnail(a,this._videos[g])},e.prototype.thumbnail=function(b,c){var d,e,f,g=c.width&&c.height?"width:"+c.width+"px;height:"+c.height+"px;":"",h=b.find("img"),i="src",j="",k=this._core.settings,l=function(c){e='<div class="owl-video-play-icon"></div>',d=k.lazyLoad?a("<div/>",{class:"owl-video-tn "+j,srcType:c}):a("<div/>",{class:"owl-video-tn",style:"opacity:1;background-image:url("+c+")"}),b.after(d),b.after(e)};if(b.wrap(a("<div/>",{class:"owl-video-wrapper",style:g})),this._core.settings.lazyLoad&&(i="data-src",j="owl-lazy"),h.length)return l(h.attr(i)),h.remove(),!1;"youtube"===c.type?(f="//img.youtube.com/vi/"+c.id+"/hqdefault.jpg",l(f)):"vimeo"===c.type?a.ajax({type:"GET",url:"//vimeo.com/api/v2/video/"+c.id+".json",jsonp:"callback",dataType:"jsonp",success:function(a){f=a[0].thumbnail_large,l(f)}}):"vzaar"===c.type&&a.ajax({type:"GET",url:"//vzaar.com/api/videos/"+c.id+".json",jsonp:"callback",dataType:"jsonp",success:function(a){f=a.framegrab_url,l(f)}})},e.prototype.stop=function(){this._core.trigger("stop",null,"video"),this._playing.find(".owl-video-frame").remove(),this._playing.removeClass("owl-video-playing"),this._playing=null,this._core.leave("playing"),this._core.trigger("stopped",null,"video")},e.prototype.play=function(b){var c,d=a(b.target),e=d.closest("."+this._core.settings.itemClass),f=this._videos[e.attr("data-video")],g=f.width||"100%",h=f.height||this._core.$stage.height();this._playing||(this._core.enter("playing"),this._core.trigger("play",null,"video"),e=this._core.items(this._core.relative(e.index())),this._core.reset(e.index()),c=a('<iframe frameborder="0" allowfullscreen mozallowfullscreen webkitAllowFullScreen ></iframe>'),c.attr("height",h),c.attr("width",g),"youtube"===f.type?c.attr("src","//www.youtube.com/embed/"+f.id+"?autoplay=1&rel=0&v="+f.id):"vimeo"===f.type?c.attr("src","//player.vimeo.com/video/"+f.id+"?autoplay=1"):"vzaar"===f.type&&c.attr("src","//view.vzaar.com/"+f.id+"/player?autoplay=true"),a(c).wrap('<div class="owl-video-frame" />').insertAfter(e.find(".owl-video")),this._playing=e.addClass("owl-video-playing"))},e.prototype.isInFullScreen=function(){var b=c.fullscreenElement||c.mozFullScreenElement||c.webkitFullscreenElement;return b&&a(b).parent().hasClass("owl-video-frame")},e.prototype.destroy=function(){var a,b;this._core.$element.off("click.owl.video");for(a in this._handlers)this._core.$element.off(a,this._handlers[a]);for(b in Object.getOwnPropertyNames(this))"function"!=typeof this[b]&&(this[b]=null)},a.fn.owlCarousel.Constructor.Plugins.Video=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){var e=function(b){this.core=b,this.core.options=a.extend({},e.Defaults,this.core.options),this.swapping=!0,this.previous=d,this.next=d,this.handlers={"change.owl.carousel":a.proxy(function(a){a.namespace&&"position"==a.property.name&&(this.previous=this.core.current(),this.next=a.property.value)},this),"drag.owl.carousel dragged.owl.carousel translated.owl.carousel":a.proxy(function(a){a.namespace&&(this.swapping="translated"==a.type)},this),"translate.owl.carousel":a.proxy(function(a){a.namespace&&this.swapping&&(this.core.options.animateOut||this.core.options.animateIn)&&this.swap()},this)},this.core.$element.on(this.handlers)};e.Defaults={animateOut:!1,
animateIn:!1},e.prototype.swap=function(){if(1===this.core.settings.items&&a.support.animation&&a.support.transition){this.core.speed(0);var b,c=a.proxy(this.clear,this),d=this.core.$stage.children().eq(this.previous),e=this.core.$stage.children().eq(this.next),f=this.core.settings.animateIn,g=this.core.settings.animateOut;this.core.current()!==this.previous&&(g&&(b=this.core.coordinates(this.previous)-this.core.coordinates(this.next),d.one(a.support.animation.end,c).css({left:b+"px"}).addClass("animated owl-animated-out").addClass(g)),f&&e.one(a.support.animation.end,c).addClass("animated owl-animated-in").addClass(f))}},e.prototype.clear=function(b){a(b.target).css({left:""}).removeClass("animated owl-animated-out owl-animated-in").removeClass(this.core.settings.animateIn).removeClass(this.core.settings.animateOut),this.core.onTransitionEnd()},e.prototype.destroy=function(){var a,b;for(a in this.handlers)this.core.$element.off(a,this.handlers[a]);for(b in Object.getOwnPropertyNames(this))"function"!=typeof this[b]&&(this[b]=null)},a.fn.owlCarousel.Constructor.Plugins.Animate=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){var e=function(b){this._core=b,this._call=null,this._time=0,this._timeout=0,this._paused=!0,this._handlers={"changed.owl.carousel":a.proxy(function(a){a.namespace&&"settings"===a.property.name?this._core.settings.autoplay?this.play():this.stop():a.namespace&&"position"===a.property.name&&this._paused&&(this._time=0)},this),"initialized.owl.carousel":a.proxy(function(a){a.namespace&&this._core.settings.autoplay&&this.play()},this),"play.owl.autoplay":a.proxy(function(a,b,c){a.namespace&&this.play(b,c)},this),"stop.owl.autoplay":a.proxy(function(a){a.namespace&&this.stop()},this),"mouseover.owl.autoplay":a.proxy(function(){this._core.settings.autoplayHoverPause&&this._core.is("rotating")&&this.pause()},this),"mouseleave.owl.autoplay":a.proxy(function(){this._core.settings.autoplayHoverPause&&this._core.is("rotating")&&this.play()},this),"touchstart.owl.core":a.proxy(function(){this._core.settings.autoplayHoverPause&&this._core.is("rotating")&&this.pause()},this),"touchend.owl.core":a.proxy(function(){this._core.settings.autoplayHoverPause&&this.play()},this)},this._core.$element.on(this._handlers),this._core.options=a.extend({},e.Defaults,this._core.options)};e.Defaults={autoplay:!1,autoplayTimeout:5e3,autoplayHoverPause:!1,autoplaySpeed:!1},e.prototype._next=function(d){this._call=b.setTimeout(a.proxy(this._next,this,d),this._timeout*(Math.round(this.read()/this._timeout)+1)-this.read()),this._core.is("interacting")||c.hidden||this._core.next(d||this._core.settings.autoplaySpeed)},e.prototype.read=function(){return(new Date).getTime()-this._time},e.prototype.play=function(c,d){var e;this._core.is("rotating")||this._core.enter("rotating"),c=c||this._core.settings.autoplayTimeout,e=Math.min(this._time%(this._timeout||c),c),this._paused?(this._time=this.read(),this._paused=!1):b.clearTimeout(this._call),this._time+=this.read()%c-e,this._timeout=c,this._call=b.setTimeout(a.proxy(this._next,this,d),c-e)},e.prototype.stop=function(){this._core.is("rotating")&&(this._time=0,this._paused=!0,b.clearTimeout(this._call),this._core.leave("rotating"))},e.prototype.pause=function(){this._core.is("rotating")&&!this._paused&&(this._time=this.read(),this._paused=!0,b.clearTimeout(this._call))},e.prototype.destroy=function(){var a,b;this.stop();for(a in this._handlers)this._core.$element.off(a,this._handlers[a]);for(b in Object.getOwnPropertyNames(this))"function"!=typeof this[b]&&(this[b]=null)},a.fn.owlCarousel.Constructor.Plugins.autoplay=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){"use strict";var e=function(b){this._core=b,this._initialized=!1,this._pages=[],this._controls={},this._templates=[],this.$element=this._core.$element,this._overrides={next:this._core.next,prev:this._core.prev,to:this._core.to},this._handlers={"prepared.owl.carousel":a.proxy(function(b){b.namespace&&this._core.settings.dotsData&&this._templates.push('<div class="'+this._core.settings.dotClass+'">'+a(b.content).find("[data-dot]").addBack("[data-dot]").attr("data-dot")+"</div>")},this),"added.owl.carousel":a.proxy(function(a){a.namespace&&this._core.settings.dotsData&&this._templates.splice(a.position,0,this._templates.pop())},this),"remove.owl.carousel":a.proxy(function(a){a.namespace&&this._core.settings.dotsData&&this._templates.splice(a.position,1)},this),"changed.owl.carousel":a.proxy(function(a){a.namespace&&"position"==a.property.name&&this.draw()},this),"initialized.owl.carousel":a.proxy(function(a){a.namespace&&!this._initialized&&(this._core.trigger("initialize",null,"navigation"),this.initialize(),this.update(),this.draw(),this._initialized=!0,this._core.trigger("initialized",null,"navigation"))},this),"refreshed.owl.carousel":a.proxy(function(a){a.namespace&&this._initialized&&(this._core.trigger("refresh",null,"navigation"),this.update(),this.draw(),this._core.trigger("refreshed",null,"navigation"))},this)},this._core.options=a.extend({},e.Defaults,this._core.options),this.$element.on(this._handlers)};e.Defaults={nav:!1,navText:['<span aria-label="Previous">&#x2039;</span>','<span aria-label="Next">&#x203a;</span>'],navSpeed:!1,navElement:'button type="button" role="presentation"',navContainer:!1,navContainerClass:"owl-nav",navClass:["owl-prev","owl-next"],slideBy:1,dotClass:"owl-dot",dotsClass:"owl-dots",dots:!0,dotsEach:!1,dotsData:!1,dotsSpeed:!1,dotsContainer:!1},e.prototype.initialize=function(){var b,c=this._core.settings;this._controls.$relative=(c.navContainer?a(c.navContainer):a("<div>").addClass(c.navContainerClass).appendTo(this.$element)).addClass("disabled"),this._controls.$previous=a("<"+c.navElement+">").addClass(c.navClass[0]).html(c.navText[0]).prependTo(this._controls.$relative).on("click",a.proxy(function(a){this.prev(c.navSpeed)},this)),this._controls.$next=a("<"+c.navElement+">").addClass(c.navClass[1]).html(c.navText[1]).appendTo(this._controls.$relative).on("click",a.proxy(function(a){this.next(c.navSpeed)},this)),c.dotsData||(this._templates=[a('<button role="button">').addClass(c.dotClass).append(a("<span>")).prop("outerHTML")]),this._controls.$absolute=(c.dotsContainer?a(c.dotsContainer):a("<div>").addClass(c.dotsClass).appendTo(this.$element)).addClass("disabled"),this._controls.$absolute.on("click","button",a.proxy(function(b){var d=a(b.target).parent().is(this._controls.$absolute)?a(b.target).index():a(b.target).parent().index();b.preventDefault(),this.to(d,c.dotsSpeed)},this));for(b in this._overrides)this._core[b]=a.proxy(this[b],this)},e.prototype.destroy=function(){var a,b,c,d,e;e=this._core.settings;for(a in this._handlers)this.$element.off(a,this._handlers[a]);for(b in this._controls)"$relative"===b&&e.navContainer?this._controls[b].html(""):this._controls[b].remove();for(d in this.overides)this._core[d]=this._overrides[d];for(c in Object.getOwnPropertyNames(this))"function"!=typeof this[c]&&(this[c]=null)},e.prototype.update=function(){var a,b,c,d=this._core.clones().length/2,e=d+this._core.items().length,f=this._core.maximum(!0),g=this._core.settings,h=g.center||g.autoWidth||g.dotsData?1:g.dotsEach||g.items;if("page"!==g.slideBy&&(g.slideBy=Math.min(g.slideBy,g.items)),g.dots||"page"==g.slideBy)for(this._pages=[],a=d,b=0,c=0;a<e;a++){if(b>=h||0===b){if(this._pages.push({start:Math.min(f,a-d),end:a-d+h-1}),Math.min(f,a-d)===f)break;b=0,++c}b+=this._core.mergers(this._core.relative(a))}},e.prototype.draw=function(){var b,c=this._core.settings,d=this._core.items().length<=c.items,e=this._core.relative(this._core.current()),f=c.loop||c.rewind;this._controls.$relative.toggleClass("disabled",!c.nav||d),c.nav&&(this._controls.$previous.toggleClass("disabled",!f&&e<=this._core.minimum(!0)),this._controls.$next.toggleClass("disabled",!f&&e>=this._core.maximum(!0))),this._controls.$absolute.toggleClass("disabled",!c.dots||d),c.dots&&(b=this._pages.length-this._controls.$absolute.children().length,c.dotsData&&0!==b?this._controls.$absolute.html(this._templates.join("")):b>0?this._controls.$absolute.append(new Array(b+1).join(this._templates[0])):b<0&&this._controls.$absolute.children().slice(b).remove(),this._controls.$absolute.find(".active").removeClass("active"),this._controls.$absolute.children().eq(a.inArray(this.current(),this._pages)).addClass("active"))},e.prototype.onTrigger=function(b){var c=this._core.settings;b.page={index:a.inArray(this.current(),this._pages),count:this._pages.length,size:c&&(c.center||c.autoWidth||c.dotsData?1:c.dotsEach||c.items)}},e.prototype.current=function(){var b=this._core.relative(this._core.current());return a.grep(this._pages,a.proxy(function(a,c){return a.start<=b&&a.end>=b},this)).pop()},e.prototype.getPosition=function(b){var c,d,e=this._core.settings;return"page"==e.slideBy?(c=a.inArray(this.current(),this._pages),d=this._pages.length,b?++c:--c,c=this._pages[(c%d+d)%d].start):(c=this._core.relative(this._core.current()),d=this._core.items().length,b?c+=e.slideBy:c-=e.slideBy),c},e.prototype.next=function(b){a.proxy(this._overrides.to,this._core)(this.getPosition(!0),b)},e.prototype.prev=function(b){a.proxy(this._overrides.to,this._core)(this.getPosition(!1),b)},e.prototype.to=function(b,c,d){var e;!d&&this._pages.length?(e=this._pages.length,a.proxy(this._overrides.to,this._core)(this._pages[(b%e+e)%e].start,c)):a.proxy(this._overrides.to,this._core)(b,c)},a.fn.owlCarousel.Constructor.Plugins.Navigation=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){"use strict";var e=function(c){this._core=c,this._hashes={},this.$element=this._core.$element,this._handlers={"initialized.owl.carousel":a.proxy(function(c){c.namespace&&"URLHash"===this._core.settings.startPosition&&a(b).trigger("hashchange.owl.navigation")},this),"prepared.owl.carousel":a.proxy(function(b){if(b.namespace){var c=a(b.content).find("[data-hash]").addBack("[data-hash]").attr("data-hash");if(!c)return;this._hashes[c]=b.content}},this),"changed.owl.carousel":a.proxy(function(c){if(c.namespace&&"position"===c.property.name){var d=this._core.items(this._core.relative(this._core.current())),e=a.map(this._hashes,function(a,b){return a===d?b:null}).join();if(!e||b.location.hash.slice(1)===e)return;b.location.hash=e}},this)},this._core.options=a.extend({},e.Defaults,this._core.options),this.$element.on(this._handlers),a(b).on("hashchange.owl.navigation",a.proxy(function(a){var c=b.location.hash.substring(1),e=this._core.$stage.children(),f=this._hashes[c]&&e.index(this._hashes[c]);f!==d&&f!==this._core.current()&&this._core.to(this._core.relative(f),!1,!0)},this))};e.Defaults={URLhashListener:!1},e.prototype.destroy=function(){var c,d;a(b).off("hashchange.owl.navigation");for(c in this._handlers)this._core.$element.off(c,this._handlers[c]);for(d in Object.getOwnPropertyNames(this))"function"!=typeof this[d]&&(this[d]=null)},a.fn.owlCarousel.Constructor.Plugins.Hash=e}(window.Zepto||window.jQuery,window,document),function(a,b,c,d){function e(b,c){var e=!1,f=b.charAt(0).toUpperCase()+b.slice(1);return a.each((b+" "+h.join(f+" ")+f).split(" "),function(a,b){if(g[b]!==d)return e=!c||b,!1}),e}function f(a){return e(a,!0)}var g=a("<support>").get(0).style,h="Webkit Moz O ms".split(" "),i={transition:{end:{WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd",transition:"transitionend"}},animation:{end:{WebkitAnimation:"webkitAnimationEnd",MozAnimation:"animationend",OAnimation:"oAnimationEnd",animation:"animationend"}}},j={csstransforms:function(){return!!e("transform")},csstransforms3d:function(){return!!e("perspective")},csstransitions:function(){return!!e("transition")},cssanimations:function(){return!!e("animation")}};j.csstransitions()&&(a.support.transition=new String(f("transition")),a.support.transition.end=i.transition.end[a.support.transition]),j.cssanimations()&&(a.support.animation=new String(f("animation")),a.support.animation.end=i.animation.end[a.support.animation]),j.csstransforms()&&(a.support.transform=new String(f("transform")),a.support.transform3d=j.csstransforms3d())}(window.Zepto||window.jQuery,window,document);
function SetPosDots() {
    var b = $(".active .pro-slider-title_mobile").outerHeight(true);
    var c = $(".active .pro-slider-img").outerHeight(true);
    $('.owl-dots').css({ 'top': b + c + 10 })
}
function SetHeghtTitleDiv() {
    var mh = 0;
    $("div.pro-slider-title_mobile").each(function () {
        var h_block = ($(this).outerHeight(true));
        if (h_block > mh) {
            mh = h_block;
        };
    });
    $("div.pro-slider-title_mobile").each(function () {
        $(this).height(mh);
    });
}
$(document).ready(function () {
    $('.pro2019Slider .owl-carousel').owlCarousel({
        loop: true,
        dots: true,
        nav: false,
        items: 1,
        margin: 50,
    });

    SetHeghtTitleDiv();
    SetPosDots();

    $(window).resize(function () {
        SetHeghtTitleDiv();
        SetPosDots();
    });
});
$(document).ready(function () {
    $('.pro2019Slider2 .owl-carousel').owlCarousel({
        loop: true,
        dots: true,
        margin: -50,
        nav: false,
        autoplay:true,/*Uncommented in HI-711*/
        center: true,
        responsive: {
            0: {
                items: 1,
                nav: false,
                margin: 20
            },
            1200: {
                items: 3,
                nav: false,
                margin: -20
            },
            1600: {
                items: 3,
                nav: false,
            }
        }
    });
});