{"version":3,"file":"cdp.js","mappings":"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","sources":["webpack://scan-static-build/./src/scripts/entry-cdp.js","webpack://scan-static-build/./src/scripts/libs/jquery/jquery-3.6.0.js","webpack://scan-static-build/./src/scripts/modules/cdp/index.js","webpack://scan-static-build/./src/scripts/modules/cdp/scan.foundation.cdp.js","webpack://scan-static-build/webpack/bootstrap","webpack://scan-static-build/webpack/runtime/define property getters","webpack://scan-static-build/webpack/runtime/hasOwnProperty shorthand","webpack://scan-static-build/webpack/startup"],"sourcesContent":["/*\r\n * This file is main entry point for CDP script\r\n */\r\ndefine(\"entry-cdp\", [\r\n    \"@modules/cdp/index\"\r\n], function (CDP) {\r\n    $(function () {\r\n        window.CDP = CDP;\r\n        setTimeout(function () {\r\n            console.log(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\");\r\n            console.log(\"CDP file\");\r\n            console.log(\"                                             \" + new Date());\r\n            console.log(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\");\r\n        }, 1500);\r\n\r\n        // Get BrowserId before calling any CDP events\r\n        CDP.getBrowserId().then(data => {\r\n            let browserId = data;\r\n            console.log(\"CDP browserId:\" + browserId);\r\n            $(\".header .tty-wrapper a[href='tel:18774525898'], .header .tty-wrapper a[href='tel:8774525898']\").on(\"click\", function () {\r\n                // Clicked click-to-call phone number - Pass Contact event to Meta\r\n                CDP.trackMeta(browserId, \"Contact\").then(data => {\r\n                    console.log(data);\r\n                });\r\n            });\r\n        });\r\n    });\r\n});\r\n","/*!\r\n * jQuery JavaScript Library v3.6.0\r\n * https://jquery.com/\r\n *\r\n * Includes Sizzle.js\r\n * https://sizzlejs.com/\r\n *\r\n * Copyright OpenJS Foundation and other contributors\r\n * Released under the MIT license\r\n * https://jquery.org/license\r\n *\r\n * Date: 2021-03-02T17:08Z\r\n */\r\n( function( global, factory ) {\r\n\r\n    \"use strict\";\r\n\r\n    if ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\r\n\r\n        // For CommonJS and CommonJS-like environments where a proper `window`\r\n        // is present, execute the factory and get jQuery.\r\n        // For environments that do not have a `window` with a `document`\r\n        // (such as Node.js), expose a factory as module.exports.\r\n        // This accentuates the need for the creation of a real `window`.\r\n        // e.g. var jQuery = require(\"jquery\")(window);\r\n        // See ticket #14549 for more info.\r\n        module.exports = global.document ?\r\n            factory( global, true ) :\r\n            function( w ) {\r\n                if ( !w.document ) {\r\n                    throw new Error( \"jQuery requires a window with a document\" );\r\n                }\r\n                return factory( w );\r\n            };\r\n    } else {\r\n        factory( global );\r\n    }\r\n\r\n// Pass this if window is not defined yet\r\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\r\n\r\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\r\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\r\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\r\n// enough that all such attempts are guarded in a try block.\r\n    \"use strict\";\r\n\r\n    var arr = [];\r\n\r\n    var getProto = Object.getPrototypeOf;\r\n\r\n    var slice = arr.slice;\r\n\r\n    var flat = arr.flat ? function( array ) {\r\n        return arr.flat.call( array );\r\n    } : function( array ) {\r\n        return arr.concat.apply( [], array );\r\n    };\r\n\r\n\r\n    var push = arr.push;\r\n\r\n    var indexOf = arr.indexOf;\r\n\r\n    var class2type = {};\r\n\r\n    var toString = class2type.toString;\r\n\r\n    var hasOwn = class2type.hasOwnProperty;\r\n\r\n    var fnToString = hasOwn.toString;\r\n\r\n    var ObjectFunctionString = fnToString.call( Object );\r\n\r\n    var support = {};\r\n\r\n    var isFunction = function isFunction( obj ) {\r\n\r\n        // Support: Chrome <=57, Firefox <=52\r\n        // In some browsers, typeof returns \"function\" for HTML <object> elements\r\n        // (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\r\n        // We don't want to classify *any* DOM node as a function.\r\n        // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5\r\n        // Plus for old WebKit, typeof returns \"function\" for HTML collections\r\n        // (e.g., `typeof document.getElementsByTagName(\"div\") === \"function\"`). (gh-4756)\r\n        return typeof obj === \"function\" && typeof obj.nodeType !== \"number\" &&\r\n            typeof obj.item !== \"function\";\r\n    };\r\n\r\n\r\n    var isWindow = function isWindow( obj ) {\r\n        return obj != null && obj === obj.window;\r\n    };\r\n\r\n\r\n    var document = window.document;\r\n\r\n\r\n\r\n    var preservedScriptAttributes = {\r\n        type: true,\r\n        src: true,\r\n        nonce: true,\r\n        noModule: true\r\n    };\r\n\r\n    function DOMEval( code, node, doc ) {\r\n        doc = doc || document;\r\n\r\n        var i, val,\r\n            script = doc.createElement( \"script\" );\r\n\r\n        script.text = code;\r\n        if ( node ) {\r\n            for ( i in preservedScriptAttributes ) {\r\n\r\n                // Support: Firefox 64+, Edge 18+\r\n                // Some browsers don't support the \"nonce\" property on scripts.\r\n                // On the other hand, just using `getAttribute` is not enough as\r\n                // the `nonce` attribute is reset to an empty string whenever it\r\n                // becomes browsing-context connected.\r\n                // See https://github.com/whatwg/html/issues/2369\r\n                // See https://html.spec.whatwg.org/#nonce-attributes\r\n                // The `node.getAttribute` check was added for the sake of\r\n                // `jQuery.globalEval` so that it can fake a nonce-containing node\r\n                // via an object.\r\n                val = node[ i ] || node.getAttribute && node.getAttribute( i );\r\n                if ( val ) {\r\n                    script.setAttribute( i, val );\r\n                }\r\n            }\r\n        }\r\n        doc.head.appendChild( script ).parentNode.removeChild( script );\r\n    }\r\n\r\n\r\n    function toType( obj ) {\r\n        if ( obj == null ) {\r\n            return obj + \"\";\r\n        }\r\n\r\n        // Support: Android <=2.3 only (functionish RegExp)\r\n        return typeof obj === \"object\" || typeof obj === \"function\" ?\r\n            class2type[ toString.call( obj ) ] || \"object\" :\r\n            typeof obj;\r\n    }\r\n    /* global Symbol */\r\n// Defining this global in .eslintrc.json would create a danger of using the global\r\n// unguarded in another place, it seems safer to define global only for this module\r\n\r\n\r\n\r\n    var\r\n        version = \"3.6.0\",\r\n\r\n        // Define a local copy of jQuery\r\n        jQuery = function( selector, context ) {\r\n\r\n            // The jQuery object is actually just the init constructor 'enhanced'\r\n            // Need init if jQuery is called (just allow error to be thrown if not included)\r\n            return new jQuery.fn.init( selector, context );\r\n        };\r\n\r\n    jQuery.fn = jQuery.prototype = {\r\n\r\n        // The current version of jQuery being used\r\n        jquery: version,\r\n\r\n        constructor: jQuery,\r\n\r\n        // The default length of a jQuery object is 0\r\n        length: 0,\r\n\r\n        toArray: function() {\r\n            return slice.call( this );\r\n        },\r\n\r\n        // Get the Nth element in the matched element set OR\r\n        // Get the whole matched element set as a clean array\r\n        get: function( num ) {\r\n\r\n            // Return all the elements in a clean array\r\n            if ( num == null ) {\r\n                return slice.call( this );\r\n            }\r\n\r\n            // Return just the one element from the set\r\n            return num < 0 ? this[ num + this.length ] : this[ num ];\r\n        },\r\n\r\n        // Take an array of elements and push it onto the stack\r\n        // (returning the new matched element set)\r\n        pushStack: function( elems ) {\r\n\r\n            // Build a new jQuery matched element set\r\n            var ret = jQuery.merge( this.constructor(), elems );\r\n\r\n            // Add the old object onto the stack (as a reference)\r\n            ret.prevObject = this;\r\n\r\n            // Return the newly-formed element set\r\n            return ret;\r\n        },\r\n\r\n        // Execute a callback for every element in the matched set.\r\n        each: function( callback ) {\r\n            return jQuery.each( this, callback );\r\n        },\r\n\r\n        map: function( callback ) {\r\n            return this.pushStack( jQuery.map( this, function( elem, i ) {\r\n                return callback.call( elem, i, elem );\r\n            } ) );\r\n        },\r\n\r\n        slice: function() {\r\n            return this.pushStack( slice.apply( this, arguments ) );\r\n        },\r\n\r\n        first: function() {\r\n            return this.eq( 0 );\r\n        },\r\n\r\n        last: function() {\r\n            return this.eq( -1 );\r\n        },\r\n\r\n        even: function() {\r\n            return this.pushStack( jQuery.grep( this, function( _elem, i ) {\r\n                return ( i + 1 ) % 2;\r\n            } ) );\r\n        },\r\n\r\n        odd: function() {\r\n            return this.pushStack( jQuery.grep( this, function( _elem, i ) {\r\n                return i % 2;\r\n            } ) );\r\n        },\r\n\r\n        eq: function( i ) {\r\n            var len = this.length,\r\n                j = +i + ( i < 0 ? len : 0 );\r\n            return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\r\n        },\r\n\r\n        end: function() {\r\n            return this.prevObject || this.constructor();\r\n        },\r\n\r\n        // For internal use only.\r\n        // Behaves like an Array's method, not like a jQuery method.\r\n        push: push,\r\n        sort: arr.sort,\r\n        splice: arr.splice\r\n    };\r\n\r\n    jQuery.extend = jQuery.fn.extend = function() {\r\n        var options, name, src, copy, copyIsArray, clone,\r\n            target = arguments[ 0 ] || {},\r\n            i = 1,\r\n            length = arguments.length,\r\n            deep = false;\r\n\r\n        // Handle a deep copy situation\r\n        if ( typeof target === \"boolean\" ) {\r\n            deep = target;\r\n\r\n            // Skip the boolean and the target\r\n            target = arguments[ i ] || {};\r\n            i++;\r\n        }\r\n\r\n        // Handle case when target is a string or something (possible in deep copy)\r\n        if ( typeof target !== \"object\" && !isFunction( target ) ) {\r\n            target = {};\r\n        }\r\n\r\n        // Extend jQuery itself if only one argument is passed\r\n        if ( i === length ) {\r\n            target = this;\r\n            i--;\r\n        }\r\n\r\n        for ( ; i < length; i++ ) {\r\n\r\n            // Only deal with non-null/undefined values\r\n            if ( ( options = arguments[ i ] ) != null ) {\r\n\r\n                // Extend the base object\r\n                for ( name in options ) {\r\n                    copy = options[ name ];\r\n\r\n                    // Prevent Object.prototype pollution\r\n                    // Prevent never-ending loop\r\n                    if ( name === \"__proto__\" || target === copy ) {\r\n                        continue;\r\n                    }\r\n\r\n                    // Recurse if we're merging plain objects or arrays\r\n                    if ( deep && copy && ( jQuery.isPlainObject( copy ) ||\r\n                        ( copyIsArray = Array.isArray( copy ) ) ) ) {\r\n                        src = target[ name ];\r\n\r\n                        // Ensure proper type for the source value\r\n                        if ( copyIsArray && !Array.isArray( src ) ) {\r\n                            clone = [];\r\n                        } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\r\n                            clone = {};\r\n                        } else {\r\n                            clone = src;\r\n                        }\r\n                        copyIsArray = false;\r\n\r\n                        // Never move original objects, clone them\r\n                        target[ name ] = jQuery.extend( deep, clone, copy );\r\n\r\n                        // Don't bring in undefined values\r\n                    } else if ( copy !== undefined ) {\r\n                        target[ name ] = copy;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Return the modified object\r\n        return target;\r\n    };\r\n\r\n    jQuery.extend( {\r\n\r\n        // Unique for each copy of jQuery on the page\r\n        expando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\r\n\r\n        // Assume jQuery is ready without the ready module\r\n        isReady: true,\r\n\r\n        error: function( msg ) {\r\n            throw new Error( msg );\r\n        },\r\n\r\n        noop: function() {},\r\n\r\n        isPlainObject: function( obj ) {\r\n            var proto, Ctor;\r\n\r\n            // Detect obvious negatives\r\n            // Use toString instead of jQuery.type to catch host objects\r\n            if ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\r\n                return false;\r\n            }\r\n\r\n            proto = getProto( obj );\r\n\r\n            // Objects with no prototype (e.g., `Object.create( null )`) are plain\r\n            if ( !proto ) {\r\n                return true;\r\n            }\r\n\r\n            // Objects with prototype are plain iff they were constructed by a global Object function\r\n            Ctor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\r\n            return typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\r\n        },\r\n\r\n        isEmptyObject: function( obj ) {\r\n            var name;\r\n\r\n            for ( name in obj ) {\r\n                return false;\r\n            }\r\n            return true;\r\n        },\r\n\r\n        // Evaluates a script in a provided context; falls back to the global one\r\n        // if not specified.\r\n        globalEval: function( code, options, doc ) {\r\n            DOMEval( code, { nonce: options && options.nonce }, doc );\r\n        },\r\n\r\n        each: function( obj, callback ) {\r\n            var length, i = 0;\r\n\r\n            if ( isArrayLike( obj ) ) {\r\n                length = obj.length;\r\n                for ( ; i < length; i++ ) {\r\n                    if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\r\n                        break;\r\n                    }\r\n                }\r\n            } else {\r\n                for ( i in obj ) {\r\n                    if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n\r\n            return obj;\r\n        },\r\n\r\n        // results is for internal usage only\r\n        makeArray: function( arr, results ) {\r\n            var ret = results || [];\r\n\r\n            if ( arr != null ) {\r\n                if ( isArrayLike( Object( arr ) ) ) {\r\n                    jQuery.merge( ret,\r\n                        typeof arr === \"string\" ?\r\n                            [ arr ] : arr\r\n                    );\r\n                } else {\r\n                    push.call( ret, arr );\r\n                }\r\n            }\r\n\r\n            return ret;\r\n        },\r\n\r\n        inArray: function( elem, arr, i ) {\r\n            return arr == null ? -1 : indexOf.call( arr, elem, i );\r\n        },\r\n\r\n        // Support: Android <=4.0 only, PhantomJS 1 only\r\n        // push.apply(_, arraylike) throws on ancient WebKit\r\n        merge: function( first, second ) {\r\n            var len = +second.length,\r\n                j = 0,\r\n                i = first.length;\r\n\r\n            for ( ; j < len; j++ ) {\r\n                first[ i++ ] = second[ j ];\r\n            }\r\n\r\n            first.length = i;\r\n\r\n            return first;\r\n        },\r\n\r\n        grep: function( elems, callback, invert ) {\r\n            var callbackInverse,\r\n                matches = [],\r\n                i = 0,\r\n                length = elems.length,\r\n                callbackExpect = !invert;\r\n\r\n            // Go through the array, only saving the items\r\n            // that pass the validator function\r\n            for ( ; i < length; i++ ) {\r\n                callbackInverse = !callback( elems[ i ], i );\r\n                if ( callbackInverse !== callbackExpect ) {\r\n                    matches.push( elems[ i ] );\r\n                }\r\n            }\r\n\r\n            return matches;\r\n        },\r\n\r\n        // arg is for internal usage only\r\n        map: function( elems, callback, arg ) {\r\n            var length, value,\r\n                i = 0,\r\n                ret = [];\r\n\r\n            // Go through the array, translating each of the items to their new values\r\n            if ( isArrayLike( elems ) ) {\r\n                length = elems.length;\r\n                for ( ; i < length; i++ ) {\r\n                    value = callback( elems[ i ], i, arg );\r\n\r\n                    if ( value != null ) {\r\n                        ret.push( value );\r\n                    }\r\n                }\r\n\r\n                // Go through every key on the object,\r\n            } else {\r\n                for ( i in elems ) {\r\n                    value = callback( elems[ i ], i, arg );\r\n\r\n                    if ( value != null ) {\r\n                        ret.push( value );\r\n                    }\r\n                }\r\n            }\r\n\r\n            // Flatten any nested arrays\r\n            return flat( ret );\r\n        },\r\n\r\n        // A global GUID counter for objects\r\n        guid: 1,\r\n\r\n        // jQuery.support is not used in Core but other projects attach their\r\n        // properties to it so it needs to exist.\r\n        support: support\r\n    } );\r\n\r\n    if ( typeof Symbol === \"function\" ) {\r\n        jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\r\n    }\r\n\r\n// Populate the class2type map\r\n    jQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\r\n        function( _i, name ) {\r\n            class2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\r\n        } );\r\n\r\n    function isArrayLike( obj ) {\r\n\r\n        // Support: real iOS 8.2 only (not reproducible in simulator)\r\n        // `in` check used to prevent JIT error (gh-2145)\r\n        // hasOwn isn't used here due to false negatives\r\n        // regarding Nodelist length in IE\r\n        var length = !!obj && \"length\" in obj && obj.length,\r\n            type = toType( obj );\r\n\r\n        if ( isFunction( obj ) || isWindow( obj ) ) {\r\n            return false;\r\n        }\r\n\r\n        return type === \"array\" || length === 0 ||\r\n            typeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\r\n    }\r\n    var Sizzle =\r\n        /*!\r\n * Sizzle CSS Selector Engine v2.3.6\r\n * https://sizzlejs.com/\r\n *\r\n * Copyright JS Foundation and other contributors\r\n * Released under the MIT license\r\n * https://js.foundation/\r\n *\r\n * Date: 2021-02-16\r\n */\r\n        ( function( window ) {\r\n            var i,\r\n                support,\r\n                Expr,\r\n                getText,\r\n                isXML,\r\n                tokenize,\r\n                compile,\r\n                select,\r\n                outermostContext,\r\n                sortInput,\r\n                hasDuplicate,\r\n\r\n                // Local document vars\r\n                setDocument,\r\n                document,\r\n                docElem,\r\n                documentIsHTML,\r\n                rbuggyQSA,\r\n                rbuggyMatches,\r\n                matches,\r\n                contains,\r\n\r\n                // Instance-specific data\r\n                expando = \"sizzle\" + 1 * new Date(),\r\n                preferredDoc = window.document,\r\n                dirruns = 0,\r\n                done = 0,\r\n                classCache = createCache(),\r\n                tokenCache = createCache(),\r\n                compilerCache = createCache(),\r\n                nonnativeSelectorCache = createCache(),\r\n                sortOrder = function( a, b ) {\r\n                    if ( a === b ) {\r\n                        hasDuplicate = true;\r\n                    }\r\n                    return 0;\r\n                },\r\n\r\n                // Instance methods\r\n                hasOwn = ( {} ).hasOwnProperty,\r\n                arr = [],\r\n                pop = arr.pop,\r\n                pushNative = arr.push,\r\n                push = arr.push,\r\n                slice = arr.slice,\r\n\r\n                // Use a stripped-down indexOf as it's faster than native\r\n                // https://jsperf.com/thor-indexof-vs-for/5\r\n                indexOf = function( list, elem ) {\r\n                    var i = 0,\r\n                        len = list.length;\r\n                    for ( ; i < len; i++ ) {\r\n                        if ( list[ i ] === elem ) {\r\n                            return i;\r\n                        }\r\n                    }\r\n                    return -1;\r\n                },\r\n\r\n                booleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|\" +\r\n                    \"ismap|loop|multiple|open|readonly|required|scoped\",\r\n\r\n                // Regular expressions\r\n\r\n                // http://www.w3.org/TR/css3-selectors/#whitespace\r\n                whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\r\n\r\n                // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\r\n                identifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\r\n                    \"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\r\n\r\n                // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\r\n                attributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\r\n\r\n                    // Operator (capture 2)\r\n                    \"*([*^$|!~]?=)\" + whitespace +\r\n\r\n                    // \"Attribute values must be CSS identifiers [capture 5]\r\n                    // or strings [capture 3 or capture 4]\"\r\n                    \"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\r\n                    whitespace + \"*\\\\]\",\r\n\r\n                pseudos = \":(\" + identifier + \")(?:\\\\((\" +\r\n\r\n                    // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\r\n                    // 1. quoted (capture 3; capture 4 or capture 5)\r\n                    \"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\r\n\r\n                    // 2. simple (capture 6)\r\n                    \"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\r\n\r\n                    // 3. anything else (capture 2)\r\n                    \".*\" +\r\n                    \")\\\\)|)\",\r\n\r\n                // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\r\n                rwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\r\n                rtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" +\r\n                    whitespace + \"+$\", \"g\" ),\r\n\r\n                rcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\r\n                rcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace +\r\n                    \"*\" ),\r\n                rdescend = new RegExp( whitespace + \"|>\" ),\r\n\r\n                rpseudo = new RegExp( pseudos ),\r\n                ridentifier = new RegExp( \"^\" + identifier + \"$\" ),\r\n\r\n                matchExpr = {\r\n                    \"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\r\n                    \"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\r\n                    \"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\r\n                    \"ATTR\": new RegExp( \"^\" + attributes ),\r\n                    \"PSEUDO\": new RegExp( \"^\" + pseudos ),\r\n                    \"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\r\n                        whitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\r\n                        whitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\r\n                    \"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\r\n\r\n                    // For use in libraries implementing .is()\r\n                    // We use this for POS matching in `select`\r\n                    \"needsContext\": new RegExp( \"^\" + whitespace +\r\n                        \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\r\n                        \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\r\n                },\r\n\r\n                rhtml = /HTML$/i,\r\n                rinputs = /^(?:input|select|textarea|button)$/i,\r\n                rheader = /^h\\d$/i,\r\n\r\n                rnative = /^[^{]+\\{\\s*\\[native \\w/,\r\n\r\n                // Easily-parseable/retrievable ID or TAG or CLASS selectors\r\n                rquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\r\n\r\n                rsibling = /[+~]/,\r\n\r\n                // CSS escapes\r\n                // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\r\n                runescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\r\n                funescape = function( escape, nonHex ) {\r\n                    var high = \"0x\" + escape.slice( 1 ) - 0x10000;\r\n\r\n                    return nonHex ?\r\n\r\n                        // Strip the backslash prefix from a non-hex escape sequence\r\n                        nonHex :\r\n\r\n                        // Replace a hexadecimal escape sequence with the encoded Unicode code point\r\n                        // Support: IE <=11+\r\n                        // For values outside the Basic Multilingual Plane (BMP), manually construct a\r\n                        // surrogate pair\r\n                        high < 0 ?\r\n                            String.fromCharCode( high + 0x10000 ) :\r\n                            String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\r\n                },\r\n\r\n                // CSS string/identifier serialization\r\n                // https://drafts.csswg.org/cssom/#common-serializing-idioms\r\n                rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\r\n                fcssescape = function( ch, asCodePoint ) {\r\n                    if ( asCodePoint ) {\r\n\r\n                        // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\r\n                        if ( ch === \"\\0\" ) {\r\n                            return \"\\uFFFD\";\r\n                        }\r\n\r\n                        // Control characters and (dependent upon position) numbers get escaped as code points\r\n                        return ch.slice( 0, -1 ) + \"\\\\\" +\r\n                            ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\r\n                    }\r\n\r\n                    // Other potentially-special ASCII characters get backslash-escaped\r\n                    return \"\\\\\" + ch;\r\n                },\r\n\r\n                // Used for iframes\r\n                // See setDocument()\r\n                // Removing the function wrapper causes a \"Permission Denied\"\r\n                // error in IE\r\n                unloadHandler = function() {\r\n                    setDocument();\r\n                },\r\n\r\n                inDisabledFieldset = addCombinator(\r\n                    function( elem ) {\r\n                        return elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\r\n                    },\r\n                    { dir: \"parentNode\", next: \"legend\" }\r\n                );\r\n\r\n// Optimize for push.apply( _, NodeList )\r\n            try {\r\n                push.apply(\r\n                    ( arr = slice.call( preferredDoc.childNodes ) ),\r\n                    preferredDoc.childNodes\r\n                );\r\n\r\n                // Support: Android<4.0\r\n                // Detect silently failing push.apply\r\n                // eslint-disable-next-line no-unused-expressions\r\n                arr[ preferredDoc.childNodes.length ].nodeType;\r\n            } catch ( e ) {\r\n                push = { apply: arr.length ?\r\n\r\n                        // Leverage slice if possible\r\n                        function( target, els ) {\r\n                            pushNative.apply( target, slice.call( els ) );\r\n                        } :\r\n\r\n                        // Support: IE<9\r\n                        // Otherwise append directly\r\n                        function( target, els ) {\r\n                            var j = target.length,\r\n                                i = 0;\r\n\r\n                            // Can't trust NodeList.length\r\n                            while ( ( target[ j++ ] = els[ i++ ] ) ) {}\r\n                            target.length = j - 1;\r\n                        }\r\n                };\r\n            }\r\n\r\n            function Sizzle( selector, context, results, seed ) {\r\n                var m, i, elem, nid, match, groups, newSelector,\r\n                    newContext = context && context.ownerDocument,\r\n\r\n                    // nodeType defaults to 9, since context defaults to document\r\n                    nodeType = context ? context.nodeType : 9;\r\n\r\n                results = results || [];\r\n\r\n                // Return early from calls with invalid selector or context\r\n                if ( typeof selector !== \"string\" || !selector ||\r\n                    nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\r\n\r\n                    return results;\r\n                }\r\n\r\n                // Try to shortcut find operations (as opposed to filters) in HTML documents\r\n                if ( !seed ) {\r\n                    setDocument( context );\r\n                    context = context || document;\r\n\r\n                    if ( documentIsHTML ) {\r\n\r\n                        // If the selector is sufficiently simple, try using a \"get*By*\" DOM method\r\n                        // (excepting DocumentFragment context, where the methods don't exist)\r\n                        if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {\r\n\r\n                            // ID selector\r\n                            if ( ( m = match[ 1 ] ) ) {\r\n\r\n                                // Document context\r\n                                if ( nodeType === 9 ) {\r\n                                    if ( ( elem = context.getElementById( m ) ) ) {\r\n\r\n                                        // Support: IE, Opera, Webkit\r\n                                        // TODO: identify versions\r\n                                        // getElementById can match elements by name instead of ID\r\n                                        if ( elem.id === m ) {\r\n                                            results.push( elem );\r\n                                            return results;\r\n                                        }\r\n                                    } else {\r\n                                        return results;\r\n                                    }\r\n\r\n                                    // Element context\r\n                                } else {\r\n\r\n                                    // Support: IE, Opera, Webkit\r\n                                    // TODO: identify versions\r\n                                    // getElementById can match elements by name instead of ID\r\n                                    if ( newContext && ( elem = newContext.getElementById( m ) ) &&\r\n                                        contains( context, elem ) &&\r\n                                        elem.id === m ) {\r\n\r\n                                        results.push( elem );\r\n                                        return results;\r\n                                    }\r\n                                }\r\n\r\n                                // Type selector\r\n                            } else if ( match[ 2 ] ) {\r\n                                push.apply( results, context.getElementsByTagName( selector ) );\r\n                                return results;\r\n\r\n                                // Class selector\r\n                            } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&\r\n                                context.getElementsByClassName ) {\r\n\r\n                                push.apply( results, context.getElementsByClassName( m ) );\r\n                                return results;\r\n                            }\r\n                        }\r\n\r\n                        // Take advantage of querySelectorAll\r\n                        if ( support.qsa &&\r\n                            !nonnativeSelectorCache[ selector + \" \" ] &&\r\n                            ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&\r\n\r\n                            // Support: IE 8 only\r\n                            // Exclude object elements\r\n                            ( nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\" ) ) {\r\n\r\n                            newSelector = selector;\r\n                            newContext = context;\r\n\r\n                            // qSA considers elements outside a scoping root when evaluating child or\r\n                            // descendant combinators, which is not what we want.\r\n                            // In such cases, we work around the behavior by prefixing every selector in the\r\n                            // list with an ID selector referencing the scope context.\r\n                            // The technique has to be used as well when a leading combinator is used\r\n                            // as such selectors are not recognized by querySelectorAll.\r\n                            // Thanks to Andrew Dupont for this technique.\r\n                            if ( nodeType === 1 &&\r\n                                ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {\r\n\r\n                                // Expand context for sibling selectors\r\n                                newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\r\n                                    context;\r\n\r\n                                // We can use :scope instead of the ID hack if the browser\r\n                                // supports it & if we're not changing the context.\r\n                                if ( newContext !== context || !support.scope ) {\r\n\r\n                                    // Capture the context ID, setting it first if necessary\r\n                                    if ( ( nid = context.getAttribute( \"id\" ) ) ) {\r\n                                        nid = nid.replace( rcssescape, fcssescape );\r\n                                    } else {\r\n                                        context.setAttribute( \"id\", ( nid = expando ) );\r\n                                    }\r\n                                }\r\n\r\n                                // Prefix every selector in the list\r\n                                groups = tokenize( selector );\r\n                                i = groups.length;\r\n                                while ( i-- ) {\r\n                                    groups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\r\n                                        toSelector( groups[ i ] );\r\n                                }\r\n                                newSelector = groups.join( \",\" );\r\n                            }\r\n\r\n                            try {\r\n                                push.apply( results,\r\n                                    newContext.querySelectorAll( newSelector )\r\n                                );\r\n                                return results;\r\n                            } catch ( qsaError ) {\r\n                                nonnativeSelectorCache( selector, true );\r\n                            } finally {\r\n                                if ( nid === expando ) {\r\n                                    context.removeAttribute( \"id\" );\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // All others\r\n                return select( selector.replace( rtrim, \"$1\" ), context, results, seed );\r\n            }\r\n\r\n            /**\r\n             * Create key-value caches of limited size\r\n             * @returns {function(string, object)} Returns the Object data after storing it on itself with\r\n             *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\r\n             *\tdeleting the oldest entry\r\n             */\r\n            function createCache() {\r\n                var keys = [];\r\n\r\n                function cache( key, value ) {\r\n\r\n                    // Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\r\n                    if ( keys.push( key + \" \" ) > Expr.cacheLength ) {\r\n\r\n                        // Only keep the most recent entries\r\n                        delete cache[ keys.shift() ];\r\n                    }\r\n                    return ( cache[ key + \" \" ] = value );\r\n                }\r\n                return cache;\r\n            }\r\n\r\n            /**\r\n             * Mark a function for special use by Sizzle\r\n             * @param {Function} fn The function to mark\r\n             */\r\n            function markFunction( fn ) {\r\n                fn[ expando ] = true;\r\n                return fn;\r\n            }\r\n\r\n            /**\r\n             * Support testing using an element\r\n             * @param {Function} fn Passed the created element and returns a boolean result\r\n             */\r\n            function assert( fn ) {\r\n                var el = document.createElement( \"fieldset\" );\r\n\r\n                try {\r\n                    return !!fn( el );\r\n                } catch ( e ) {\r\n                    return false;\r\n                } finally {\r\n\r\n                    // Remove from its parent by default\r\n                    if ( el.parentNode ) {\r\n                        el.parentNode.removeChild( el );\r\n                    }\r\n\r\n                    // release memory in IE\r\n                    el = null;\r\n                }\r\n            }\r\n\r\n            /**\r\n             * Adds the same handler for all of the specified attrs\r\n             * @param {String} attrs Pipe-separated list of attributes\r\n             * @param {Function} handler The method that will be applied\r\n             */\r\n            function addHandle( attrs, handler ) {\r\n                var arr = attrs.split( \"|\" ),\r\n                    i = arr.length;\r\n\r\n                while ( i-- ) {\r\n                    Expr.attrHandle[ arr[ i ] ] = handler;\r\n                }\r\n            }\r\n\r\n            /**\r\n             * Checks document order of two siblings\r\n             * @param {Element} a\r\n             * @param {Element} b\r\n             * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\r\n             */\r\n            function siblingCheck( a, b ) {\r\n                var cur = b && a,\r\n                    diff = cur && a.nodeType === 1 && b.nodeType === 1 &&\r\n                        a.sourceIndex - b.sourceIndex;\r\n\r\n                // Use IE sourceIndex if available on both nodes\r\n                if ( diff ) {\r\n                    return diff;\r\n                }\r\n\r\n                // Check if b follows a\r\n                if ( cur ) {\r\n                    while ( ( cur = cur.nextSibling ) ) {\r\n                        if ( cur === b ) {\r\n                            return -1;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                return a ? 1 : -1;\r\n            }\r\n\r\n            /**\r\n             * Returns a function to use in pseudos for input types\r\n             * @param {String} type\r\n             */\r\n            function createInputPseudo( type ) {\r\n                return function( elem ) {\r\n                    var name = elem.nodeName.toLowerCase();\r\n                    return name === \"input\" && elem.type === type;\r\n                };\r\n            }\r\n\r\n            /**\r\n             * Returns a function to use in pseudos for buttons\r\n             * @param {String} type\r\n             */\r\n            function createButtonPseudo( type ) {\r\n                return function( elem ) {\r\n                    var name = elem.nodeName.toLowerCase();\r\n                    return ( name === \"input\" || name === \"button\" ) && elem.type === type;\r\n                };\r\n            }\r\n\r\n            /**\r\n             * Returns a function to use in pseudos for :enabled/:disabled\r\n             * @param {Boolean} disabled true for :disabled; false for :enabled\r\n             */\r\n            function createDisabledPseudo( disabled ) {\r\n\r\n                // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\r\n                return function( elem ) {\r\n\r\n                    // Only certain elements can match :enabled or :disabled\r\n                    // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\r\n                    // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\r\n                    if ( \"form\" in elem ) {\r\n\r\n                        // Check for inherited disabledness on relevant non-disabled elements:\r\n                        // * listed form-associated elements in a disabled fieldset\r\n                        //   https://html.spec.whatwg.org/multipage/forms.html#category-listed\r\n                        //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\r\n                        // * option elements in a disabled optgroup\r\n                        //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\r\n                        // All such elements have a \"form\" property.\r\n                        if ( elem.parentNode && elem.disabled === false ) {\r\n\r\n                            // Option elements defer to a parent optgroup if present\r\n                            if ( \"label\" in elem ) {\r\n                                if ( \"label\" in elem.parentNode ) {\r\n                                    return elem.parentNode.disabled === disabled;\r\n                                } else {\r\n                                    return elem.disabled === disabled;\r\n                                }\r\n                            }\r\n\r\n                            // Support: IE 6 - 11\r\n                            // Use the isDisabled shortcut property to check for disabled fieldset ancestors\r\n                            return elem.isDisabled === disabled ||\r\n\r\n                                // Where there is no isDisabled, check manually\r\n                                /* jshint -W018 */\r\n                                elem.isDisabled !== !disabled &&\r\n                                inDisabledFieldset( elem ) === disabled;\r\n                        }\r\n\r\n                        return elem.disabled === disabled;\r\n\r\n                        // Try to winnow out elements that can't be disabled before trusting the disabled property.\r\n                        // Some victims get caught in our net (label, legend, menu, track), but it shouldn't\r\n                        // even exist on them, let alone have a boolean value.\r\n                    } else if ( \"label\" in elem ) {\r\n                        return elem.disabled === disabled;\r\n                    }\r\n\r\n                    // Remaining elements are neither :enabled nor :disabled\r\n                    return false;\r\n                };\r\n            }\r\n\r\n            /**\r\n             * Returns a function to use in pseudos for positionals\r\n             * @param {Function} fn\r\n             */\r\n            function createPositionalPseudo( fn ) {\r\n                return markFunction( function( argument ) {\r\n                    argument = +argument;\r\n                    return markFunction( function( seed, matches ) {\r\n                        var j,\r\n                            matchIndexes = fn( [], seed.length, argument ),\r\n                            i = matchIndexes.length;\r\n\r\n                        // Match elements found at the specified indexes\r\n                        while ( i-- ) {\r\n                            if ( seed[ ( j = matchIndexes[ i ] ) ] ) {\r\n                                seed[ j ] = !( matches[ j ] = seed[ j ] );\r\n                            }\r\n                        }\r\n                    } );\r\n                } );\r\n            }\r\n\r\n            /**\r\n             * Checks a node for validity as a Sizzle context\r\n             * @param {Element|Object=} context\r\n             * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\r\n             */\r\n            function testContext( context ) {\r\n                return context && typeof context.getElementsByTagName !== \"undefined\" && context;\r\n            }\r\n\r\n// Expose support vars for convenience\r\n            support = Sizzle.support = {};\r\n\r\n            /**\r\n             * Detects XML nodes\r\n             * @param {Element|Object} elem An element or a document\r\n             * @returns {Boolean} True iff elem is a non-HTML XML node\r\n             */\r\n            isXML = Sizzle.isXML = function( elem ) {\r\n                var namespace = elem && elem.namespaceURI,\r\n                    docElem = elem && ( elem.ownerDocument || elem ).documentElement;\r\n\r\n                // Support: IE <=8\r\n                // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\r\n                // https://bugs.jquery.com/ticket/4833\r\n                return !rhtml.test( namespace || docElem && docElem.nodeName || \"HTML\" );\r\n            };\r\n\r\n            /**\r\n             * Sets document-related variables once based on the current document\r\n             * @param {Element|Object} [doc] An element or document object to use to set the document\r\n             * @returns {Object} Returns the current document\r\n             */\r\n            setDocument = Sizzle.setDocument = function( node ) {\r\n                var hasCompare, subWindow,\r\n                    doc = node ? node.ownerDocument || node : preferredDoc;\r\n\r\n                // Return early if doc is invalid or already selected\r\n                // Support: IE 11+, Edge 17 - 18+\r\n                // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                // two documents; shallow comparisons work.\r\n                // eslint-disable-next-line eqeqeq\r\n                if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {\r\n                    return document;\r\n                }\r\n\r\n                // Update global variables\r\n                document = doc;\r\n                docElem = document.documentElement;\r\n                documentIsHTML = !isXML( document );\r\n\r\n                // Support: IE 9 - 11+, Edge 12 - 18+\r\n                // Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\r\n                // Support: IE 11+, Edge 17 - 18+\r\n                // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                // two documents; shallow comparisons work.\r\n                // eslint-disable-next-line eqeqeq\r\n                if ( preferredDoc != document &&\r\n                    ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\r\n\r\n                    // Support: IE 11, Edge\r\n                    if ( subWindow.addEventListener ) {\r\n                        subWindow.addEventListener( \"unload\", unloadHandler, false );\r\n\r\n                        // Support: IE 9 - 10 only\r\n                    } else if ( subWindow.attachEvent ) {\r\n                        subWindow.attachEvent( \"onunload\", unloadHandler );\r\n                    }\r\n                }\r\n\r\n                // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,\r\n                // Safari 4 - 5 only, Opera <=11.6 - 12.x only\r\n                // IE/Edge & older browsers don't support the :scope pseudo-class.\r\n                // Support: Safari 6.0 only\r\n                // Safari 6.0 supports :scope but it's an alias of :root there.\r\n                support.scope = assert( function( el ) {\r\n                    docElem.appendChild( el ).appendChild( document.createElement( \"div\" ) );\r\n                    return typeof el.querySelectorAll !== \"undefined\" &&\r\n                        !el.querySelectorAll( \":scope fieldset div\" ).length;\r\n                } );\r\n\r\n                /* Attributes\r\n\t---------------------------------------------------------------------- */\r\n\r\n                // Support: IE<8\r\n                // Verify that getAttribute really returns attributes and not properties\r\n                // (excepting IE8 booleans)\r\n                support.attributes = assert( function( el ) {\r\n                    el.className = \"i\";\r\n                    return !el.getAttribute( \"className\" );\r\n                } );\r\n\r\n                /* getElement(s)By*\r\n\t---------------------------------------------------------------------- */\r\n\r\n                // Check if getElementsByTagName(\"*\") returns only elements\r\n                support.getElementsByTagName = assert( function( el ) {\r\n                    el.appendChild( document.createComment( \"\" ) );\r\n                    return !el.getElementsByTagName( \"*\" ).length;\r\n                } );\r\n\r\n                // Support: IE<9\r\n                support.getElementsByClassName = rnative.test( document.getElementsByClassName );\r\n\r\n                // Support: IE<10\r\n                // Check if getElementById returns elements by name\r\n                // The broken getElementById methods don't pick up programmatically-set names,\r\n                // so use a roundabout getElementsByName test\r\n                support.getById = assert( function( el ) {\r\n                    docElem.appendChild( el ).id = expando;\r\n                    return !document.getElementsByName || !document.getElementsByName( expando ).length;\r\n                } );\r\n\r\n                // ID filter and find\r\n                if ( support.getById ) {\r\n                    Expr.filter[ \"ID\" ] = function( id ) {\r\n                        var attrId = id.replace( runescape, funescape );\r\n                        return function( elem ) {\r\n                            return elem.getAttribute( \"id\" ) === attrId;\r\n                        };\r\n                    };\r\n                    Expr.find[ \"ID\" ] = function( id, context ) {\r\n                        if ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\r\n                            var elem = context.getElementById( id );\r\n                            return elem ? [ elem ] : [];\r\n                        }\r\n                    };\r\n                } else {\r\n                    Expr.filter[ \"ID\" ] =  function( id ) {\r\n                        var attrId = id.replace( runescape, funescape );\r\n                        return function( elem ) {\r\n                            var node = typeof elem.getAttributeNode !== \"undefined\" &&\r\n                                elem.getAttributeNode( \"id\" );\r\n                            return node && node.value === attrId;\r\n                        };\r\n                    };\r\n\r\n                    // Support: IE 6 - 7 only\r\n                    // getElementById is not reliable as a find shortcut\r\n                    Expr.find[ \"ID\" ] = function( id, context ) {\r\n                        if ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\r\n                            var node, i, elems,\r\n                                elem = context.getElementById( id );\r\n\r\n                            if ( elem ) {\r\n\r\n                                // Verify the id attribute\r\n                                node = elem.getAttributeNode( \"id\" );\r\n                                if ( node && node.value === id ) {\r\n                                    return [ elem ];\r\n                                }\r\n\r\n                                // Fall back on getElementsByName\r\n                                elems = context.getElementsByName( id );\r\n                                i = 0;\r\n                                while ( ( elem = elems[ i++ ] ) ) {\r\n                                    node = elem.getAttributeNode( \"id\" );\r\n                                    if ( node && node.value === id ) {\r\n                                        return [ elem ];\r\n                                    }\r\n                                }\r\n                            }\r\n\r\n                            return [];\r\n                        }\r\n                    };\r\n                }\r\n\r\n                // Tag\r\n                Expr.find[ \"TAG\" ] = support.getElementsByTagName ?\r\n                    function( tag, context ) {\r\n                        if ( typeof context.getElementsByTagName !== \"undefined\" ) {\r\n                            return context.getElementsByTagName( tag );\r\n\r\n                            // DocumentFragment nodes don't have gEBTN\r\n                        } else if ( support.qsa ) {\r\n                            return context.querySelectorAll( tag );\r\n                        }\r\n                    } :\r\n\r\n                    function( tag, context ) {\r\n                        var elem,\r\n                            tmp = [],\r\n                            i = 0,\r\n\r\n                            // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\r\n                            results = context.getElementsByTagName( tag );\r\n\r\n                        // Filter out possible comments\r\n                        if ( tag === \"*\" ) {\r\n                            while ( ( elem = results[ i++ ] ) ) {\r\n                                if ( elem.nodeType === 1 ) {\r\n                                    tmp.push( elem );\r\n                                }\r\n                            }\r\n\r\n                            return tmp;\r\n                        }\r\n                        return results;\r\n                    };\r\n\r\n                // Class\r\n                Expr.find[ \"CLASS\" ] = support.getElementsByClassName && function( className, context ) {\r\n                    if ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\r\n                        return context.getElementsByClassName( className );\r\n                    }\r\n                };\r\n\r\n                /* QSA/matchesSelector\r\n\t---------------------------------------------------------------------- */\r\n\r\n                // QSA and matchesSelector support\r\n\r\n                // matchesSelector(:active) reports false when true (IE9/Opera 11.5)\r\n                rbuggyMatches = [];\r\n\r\n                // qSa(:focus) reports false when true (Chrome 21)\r\n                // We allow this because of a bug in IE8/9 that throws an error\r\n                // whenever `document.activeElement` is accessed on an iframe\r\n                // So, we allow :focus to pass through QSA all the time to avoid the IE error\r\n                // See https://bugs.jquery.com/ticket/13378\r\n                rbuggyQSA = [];\r\n\r\n                if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {\r\n\r\n                    // Build QSA regex\r\n                    // Regex strategy adopted from Diego Perini\r\n                    assert( function( el ) {\r\n\r\n                        var input;\r\n\r\n                        // Select is set to empty string on purpose\r\n                        // This is to test IE's treatment of not explicitly\r\n                        // setting a boolean content attribute,\r\n                        // since its presence should be enough\r\n                        // https://bugs.jquery.com/ticket/12359\r\n                        docElem.appendChild( el ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\r\n                            \"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\r\n                            \"<option selected=''></option></select>\";\r\n\r\n                        // Support: IE8, Opera 11-12.16\r\n                        // Nothing should be selected when empty strings follow ^= or $= or *=\r\n                        // The test attribute must be unknown in Opera but \"safe\" for WinRT\r\n                        // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\r\n                        if ( el.querySelectorAll( \"[msallowcapture^='']\" ).length ) {\r\n                            rbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\r\n                        }\r\n\r\n                        // Support: IE8\r\n                        // Boolean attributes and \"value\" are not treated correctly\r\n                        if ( !el.querySelectorAll( \"[selected]\" ).length ) {\r\n                            rbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\r\n                        }\r\n\r\n                        // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\r\n                        if ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\r\n                            rbuggyQSA.push( \"~=\" );\r\n                        }\r\n\r\n                        // Support: IE 11+, Edge 15 - 18+\r\n                        // IE 11/Edge don't find elements on a `[name='']` query in some cases.\r\n                        // Adding a temporary attribute to the document before the selection works\r\n                        // around the issue.\r\n                        // Interestingly, IE 10 & older don't seem to have the issue.\r\n                        input = document.createElement( \"input\" );\r\n                        input.setAttribute( \"name\", \"\" );\r\n                        el.appendChild( input );\r\n                        if ( !el.querySelectorAll( \"[name='']\" ).length ) {\r\n                            rbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\r\n                                whitespace + \"*(?:''|\\\"\\\")\" );\r\n                        }\r\n\r\n                        // Webkit/Opera - :checked should return selected option elements\r\n                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\r\n                        // IE8 throws error here and will not see later tests\r\n                        if ( !el.querySelectorAll( \":checked\" ).length ) {\r\n                            rbuggyQSA.push( \":checked\" );\r\n                        }\r\n\r\n                        // Support: Safari 8+, iOS 8+\r\n                        // https://bugs.webkit.org/show_bug.cgi?id=136851\r\n                        // In-page `selector#id sibling-combinator selector` fails\r\n                        if ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\r\n                            rbuggyQSA.push( \".#.+[+~]\" );\r\n                        }\r\n\r\n                        // Support: Firefox <=3.6 - 5 only\r\n                        // Old Firefox doesn't throw on a badly-escaped identifier.\r\n                        el.querySelectorAll( \"\\\\\\f\" );\r\n                        rbuggyQSA.push( \"[\\\\r\\\\n\\\\f]\" );\r\n                    } );\r\n\r\n                    assert( function( el ) {\r\n                        el.innerHTML = \"<a href='' disabled='disabled'></a>\" +\r\n                            \"<select disabled='disabled'><option/></select>\";\r\n\r\n                        // Support: Windows 8 Native Apps\r\n                        // The type and name attributes are restricted during .innerHTML assignment\r\n                        var input = document.createElement( \"input\" );\r\n                        input.setAttribute( \"type\", \"hidden\" );\r\n                        el.appendChild( input ).setAttribute( \"name\", \"D\" );\r\n\r\n                        // Support: IE8\r\n                        // Enforce case-sensitivity of name attribute\r\n                        if ( el.querySelectorAll( \"[name=d]\" ).length ) {\r\n                            rbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\r\n                        }\r\n\r\n                        // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\r\n                        // IE8 throws error here and will not see later tests\r\n                        if ( el.querySelectorAll( \":enabled\" ).length !== 2 ) {\r\n                            rbuggyQSA.push( \":enabled\", \":disabled\" );\r\n                        }\r\n\r\n                        // Support: IE9-11+\r\n                        // IE's :disabled selector does not pick up the children of disabled fieldsets\r\n                        docElem.appendChild( el ).disabled = true;\r\n                        if ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\r\n                            rbuggyQSA.push( \":enabled\", \":disabled\" );\r\n                        }\r\n\r\n                        // Support: Opera 10 - 11 only\r\n                        // Opera 10-11 does not throw on post-comma invalid pseudos\r\n                        el.querySelectorAll( \"*,:x\" );\r\n                        rbuggyQSA.push( \",.*:\" );\r\n                    } );\r\n                }\r\n\r\n                if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||\r\n                    docElem.webkitMatchesSelector ||\r\n                    docElem.mozMatchesSelector ||\r\n                    docElem.oMatchesSelector ||\r\n                    docElem.msMatchesSelector ) ) ) ) {\r\n\r\n                    assert( function( el ) {\r\n\r\n                        // Check to see if it's possible to do matchesSelector\r\n                        // on a disconnected node (IE 9)\r\n                        support.disconnectedMatch = matches.call( el, \"*\" );\r\n\r\n                        // This should fail with an exception\r\n                        // Gecko does not error, returns false instead\r\n                        matches.call( el, \"[s!='']:x\" );\r\n                        rbuggyMatches.push( \"!=\", pseudos );\r\n                    } );\r\n                }\r\n\r\n                rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\r\n                rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( \"|\" ) );\r\n\r\n                /* Contains\r\n\t---------------------------------------------------------------------- */\r\n                hasCompare = rnative.test( docElem.compareDocumentPosition );\r\n\r\n                // Element contains another\r\n                // Purposefully self-exclusive\r\n                // As in, an element does not contain itself\r\n                contains = hasCompare || rnative.test( docElem.contains ) ?\r\n                    function( a, b ) {\r\n                        var adown = a.nodeType === 9 ? a.documentElement : a,\r\n                            bup = b && b.parentNode;\r\n                        return a === bup || !!( bup && bup.nodeType === 1 && (\r\n                            adown.contains ?\r\n                                adown.contains( bup ) :\r\n                                a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\r\n                        ) );\r\n                    } :\r\n                    function( a, b ) {\r\n                        if ( b ) {\r\n                            while ( ( b = b.parentNode ) ) {\r\n                                if ( b === a ) {\r\n                                    return true;\r\n                                }\r\n                            }\r\n                        }\r\n                        return false;\r\n                    };\r\n\r\n                /* Sorting\r\n\t---------------------------------------------------------------------- */\r\n\r\n                // Document order sorting\r\n                sortOrder = hasCompare ?\r\n                    function( a, b ) {\r\n\r\n                        // Flag for duplicate removal\r\n                        if ( a === b ) {\r\n                            hasDuplicate = true;\r\n                            return 0;\r\n                        }\r\n\r\n                        // Sort on method existence if only one input has compareDocumentPosition\r\n                        var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\r\n                        if ( compare ) {\r\n                            return compare;\r\n                        }\r\n\r\n                        // Calculate position if both inputs belong to the same document\r\n                        // Support: IE 11+, Edge 17 - 18+\r\n                        // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                        // two documents; shallow comparisons work.\r\n                        // eslint-disable-next-line eqeqeq\r\n                        compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\r\n                            a.compareDocumentPosition( b ) :\r\n\r\n                            // Otherwise we know they are disconnected\r\n                            1;\r\n\r\n                        // Disconnected nodes\r\n                        if ( compare & 1 ||\r\n                            ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {\r\n\r\n                            // Choose the first element that is related to our preferred document\r\n                            // Support: IE 11+, Edge 17 - 18+\r\n                            // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                            // two documents; shallow comparisons work.\r\n                            // eslint-disable-next-line eqeqeq\r\n                            if ( a == document || a.ownerDocument == preferredDoc &&\r\n                                contains( preferredDoc, a ) ) {\r\n                                return -1;\r\n                            }\r\n\r\n                            // Support: IE 11+, Edge 17 - 18+\r\n                            // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                            // two documents; shallow comparisons work.\r\n                            // eslint-disable-next-line eqeqeq\r\n                            if ( b == document || b.ownerDocument == preferredDoc &&\r\n                                contains( preferredDoc, b ) ) {\r\n                                return 1;\r\n                            }\r\n\r\n                            // Maintain original order\r\n                            return sortInput ?\r\n                                ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\r\n                                0;\r\n                        }\r\n\r\n                        return compare & 4 ? -1 : 1;\r\n                    } :\r\n                    function( a, b ) {\r\n\r\n                        // Exit early if the nodes are identical\r\n                        if ( a === b ) {\r\n                            hasDuplicate = true;\r\n                            return 0;\r\n                        }\r\n\r\n                        var cur,\r\n                            i = 0,\r\n                            aup = a.parentNode,\r\n                            bup = b.parentNode,\r\n                            ap = [ a ],\r\n                            bp = [ b ];\r\n\r\n                        // Parentless nodes are either documents or disconnected\r\n                        if ( !aup || !bup ) {\r\n\r\n                            // Support: IE 11+, Edge 17 - 18+\r\n                            // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                            // two documents; shallow comparisons work.\r\n                            /* eslint-disable eqeqeq */\r\n                            return a == document ? -1 :\r\n                                b == document ? 1 :\r\n                                    /* eslint-enable eqeqeq */\r\n                                    aup ? -1 :\r\n                                        bup ? 1 :\r\n                                            sortInput ?\r\n                                                ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\r\n                                                0;\r\n\r\n                            // If the nodes are siblings, we can do a quick check\r\n                        } else if ( aup === bup ) {\r\n                            return siblingCheck( a, b );\r\n                        }\r\n\r\n                        // Otherwise we need full lists of their ancestors for comparison\r\n                        cur = a;\r\n                        while ( ( cur = cur.parentNode ) ) {\r\n                            ap.unshift( cur );\r\n                        }\r\n                        cur = b;\r\n                        while ( ( cur = cur.parentNode ) ) {\r\n                            bp.unshift( cur );\r\n                        }\r\n\r\n                        // Walk down the tree looking for a discrepancy\r\n                        while ( ap[ i ] === bp[ i ] ) {\r\n                            i++;\r\n                        }\r\n\r\n                        return i ?\r\n\r\n                            // Do a sibling check if the nodes have a common ancestor\r\n                            siblingCheck( ap[ i ], bp[ i ] ) :\r\n\r\n                            // Otherwise nodes in our document sort first\r\n                            // Support: IE 11+, Edge 17 - 18+\r\n                            // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                            // two documents; shallow comparisons work.\r\n                            /* eslint-disable eqeqeq */\r\n                            ap[ i ] == preferredDoc ? -1 :\r\n                                bp[ i ] == preferredDoc ? 1 :\r\n                                    /* eslint-enable eqeqeq */\r\n                                    0;\r\n                    };\r\n\r\n                return document;\r\n            };\r\n\r\n            Sizzle.matches = function( expr, elements ) {\r\n                return Sizzle( expr, null, null, elements );\r\n            };\r\n\r\n            Sizzle.matchesSelector = function( elem, expr ) {\r\n                setDocument( elem );\r\n\r\n                if ( support.matchesSelector && documentIsHTML &&\r\n                    !nonnativeSelectorCache[ expr + \" \" ] &&\r\n                    ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\r\n                    ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {\r\n\r\n                    try {\r\n                        var ret = matches.call( elem, expr );\r\n\r\n                        // IE 9's matchesSelector returns false on disconnected nodes\r\n                        if ( ret || support.disconnectedMatch ||\r\n\r\n                            // As well, disconnected nodes are said to be in a document\r\n                            // fragment in IE 9\r\n                            elem.document && elem.document.nodeType !== 11 ) {\r\n                            return ret;\r\n                        }\r\n                    } catch ( e ) {\r\n                        nonnativeSelectorCache( expr, true );\r\n                    }\r\n                }\r\n\r\n                return Sizzle( expr, document, null, [ elem ] ).length > 0;\r\n            };\r\n\r\n            Sizzle.contains = function( context, elem ) {\r\n\r\n                // Set document vars if needed\r\n                // Support: IE 11+, Edge 17 - 18+\r\n                // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                // two documents; shallow comparisons work.\r\n                // eslint-disable-next-line eqeqeq\r\n                if ( ( context.ownerDocument || context ) != document ) {\r\n                    setDocument( context );\r\n                }\r\n                return contains( context, elem );\r\n            };\r\n\r\n            Sizzle.attr = function( elem, name ) {\r\n\r\n                // Set document vars if needed\r\n                // Support: IE 11+, Edge 17 - 18+\r\n                // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                // two documents; shallow comparisons work.\r\n                // eslint-disable-next-line eqeqeq\r\n                if ( ( elem.ownerDocument || elem ) != document ) {\r\n                    setDocument( elem );\r\n                }\r\n\r\n                var fn = Expr.attrHandle[ name.toLowerCase() ],\r\n\r\n                    // Don't get fooled by Object.prototype properties (jQuery #13807)\r\n                    val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\r\n                        fn( elem, name, !documentIsHTML ) :\r\n                        undefined;\r\n\r\n                return val !== undefined ?\r\n                    val :\r\n                    support.attributes || !documentIsHTML ?\r\n                        elem.getAttribute( name ) :\r\n                        ( val = elem.getAttributeNode( name ) ) && val.specified ?\r\n                            val.value :\r\n                            null;\r\n            };\r\n\r\n            Sizzle.escape = function( sel ) {\r\n                return ( sel + \"\" ).replace( rcssescape, fcssescape );\r\n            };\r\n\r\n            Sizzle.error = function( msg ) {\r\n                throw new Error( \"Syntax error, unrecognized expression: \" + msg );\r\n            };\r\n\r\n            /**\r\n             * Document sorting and removing duplicates\r\n             * @param {ArrayLike} results\r\n             */\r\n            Sizzle.uniqueSort = function( results ) {\r\n                var elem,\r\n                    duplicates = [],\r\n                    j = 0,\r\n                    i = 0;\r\n\r\n                // Unless we *know* we can detect duplicates, assume their presence\r\n                hasDuplicate = !support.detectDuplicates;\r\n                sortInput = !support.sortStable && results.slice( 0 );\r\n                results.sort( sortOrder );\r\n\r\n                if ( hasDuplicate ) {\r\n                    while ( ( elem = results[ i++ ] ) ) {\r\n                        if ( elem === results[ i ] ) {\r\n                            j = duplicates.push( i );\r\n                        }\r\n                    }\r\n                    while ( j-- ) {\r\n                        results.splice( duplicates[ j ], 1 );\r\n                    }\r\n                }\r\n\r\n                // Clear input after sorting to release objects\r\n                // See https://github.com/jquery/sizzle/pull/225\r\n                sortInput = null;\r\n\r\n                return results;\r\n            };\r\n\r\n            /**\r\n             * Utility function for retrieving the text value of an array of DOM nodes\r\n             * @param {Array|Element} elem\r\n             */\r\n            getText = Sizzle.getText = function( elem ) {\r\n                var node,\r\n                    ret = \"\",\r\n                    i = 0,\r\n                    nodeType = elem.nodeType;\r\n\r\n                if ( !nodeType ) {\r\n\r\n                    // If no nodeType, this is expected to be an array\r\n                    while ( ( node = elem[ i++ ] ) ) {\r\n\r\n                        // Do not traverse comment nodes\r\n                        ret += getText( node );\r\n                    }\r\n                } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\r\n\r\n                    // Use textContent for elements\r\n                    // innerText usage removed for consistency of new lines (jQuery #11153)\r\n                    if ( typeof elem.textContent === \"string\" ) {\r\n                        return elem.textContent;\r\n                    } else {\r\n\r\n                        // Traverse its children\r\n                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\r\n                            ret += getText( elem );\r\n                        }\r\n                    }\r\n                } else if ( nodeType === 3 || nodeType === 4 ) {\r\n                    return elem.nodeValue;\r\n                }\r\n\r\n                // Do not include comment or processing instruction nodes\r\n\r\n                return ret;\r\n            };\r\n\r\n            Expr = Sizzle.selectors = {\r\n\r\n                // Can be adjusted by the user\r\n                cacheLength: 50,\r\n\r\n                createPseudo: markFunction,\r\n\r\n                match: matchExpr,\r\n\r\n                attrHandle: {},\r\n\r\n                find: {},\r\n\r\n                relative: {\r\n                    \">\": { dir: \"parentNode\", first: true },\r\n                    \" \": { dir: \"parentNode\" },\r\n                    \"+\": { dir: \"previousSibling\", first: true },\r\n                    \"~\": { dir: \"previousSibling\" }\r\n                },\r\n\r\n                preFilter: {\r\n                    \"ATTR\": function( match ) {\r\n                        match[ 1 ] = match[ 1 ].replace( runescape, funescape );\r\n\r\n                        // Move the given value to match[3] whether quoted or unquoted\r\n                        match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||\r\n                            match[ 5 ] || \"\" ).replace( runescape, funescape );\r\n\r\n                        if ( match[ 2 ] === \"~=\" ) {\r\n                            match[ 3 ] = \" \" + match[ 3 ] + \" \";\r\n                        }\r\n\r\n                        return match.slice( 0, 4 );\r\n                    },\r\n\r\n                    \"CHILD\": function( match ) {\r\n\r\n                        /* matches from matchExpr[\"CHILD\"]\r\n\t\t\t\t1 type (only|nth|...)\r\n\t\t\t\t2 what (child|of-type)\r\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\r\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\r\n\t\t\t\t5 sign of xn-component\r\n\t\t\t\t6 x of xn-component\r\n\t\t\t\t7 sign of y-component\r\n\t\t\t\t8 y of y-component\r\n\t\t\t*/\r\n                        match[ 1 ] = match[ 1 ].toLowerCase();\r\n\r\n                        if ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\r\n\r\n                            // nth-* requires argument\r\n                            if ( !match[ 3 ] ) {\r\n                                Sizzle.error( match[ 0 ] );\r\n                            }\r\n\r\n                            // numeric x and y parameters for Expr.filter.CHILD\r\n                            // remember that false/true cast respectively to 0/1\r\n                            match[ 4 ] = +( match[ 4 ] ?\r\n                                match[ 5 ] + ( match[ 6 ] || 1 ) :\r\n                                2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" ) );\r\n                            match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\r\n\r\n                            // other types prohibit arguments\r\n                        } else if ( match[ 3 ] ) {\r\n                            Sizzle.error( match[ 0 ] );\r\n                        }\r\n\r\n                        return match;\r\n                    },\r\n\r\n                    \"PSEUDO\": function( match ) {\r\n                        var excess,\r\n                            unquoted = !match[ 6 ] && match[ 2 ];\r\n\r\n                        if ( matchExpr[ \"CHILD\" ].test( match[ 0 ] ) ) {\r\n                            return null;\r\n                        }\r\n\r\n                        // Accept quoted arguments as-is\r\n                        if ( match[ 3 ] ) {\r\n                            match[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\r\n\r\n                            // Strip excess characters from unquoted arguments\r\n                        } else if ( unquoted && rpseudo.test( unquoted ) &&\r\n\r\n                            // Get excess from tokenize (recursively)\r\n                            ( excess = tokenize( unquoted, true ) ) &&\r\n\r\n                            // advance to the next closing parenthesis\r\n                            ( excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length ) ) {\r\n\r\n                            // excess is a negative index\r\n                            match[ 0 ] = match[ 0 ].slice( 0, excess );\r\n                            match[ 2 ] = unquoted.slice( 0, excess );\r\n                        }\r\n\r\n                        // Return only captures needed by the pseudo filter method (type and argument)\r\n                        return match.slice( 0, 3 );\r\n                    }\r\n                },\r\n\r\n                filter: {\r\n\r\n                    \"TAG\": function( nodeNameSelector ) {\r\n                        var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\r\n                        return nodeNameSelector === \"*\" ?\r\n                            function() {\r\n                                return true;\r\n                            } :\r\n                            function( elem ) {\r\n                                return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\r\n                            };\r\n                    },\r\n\r\n                    \"CLASS\": function( className ) {\r\n                        var pattern = classCache[ className + \" \" ];\r\n\r\n                        return pattern ||\r\n                            ( pattern = new RegExp( \"(^|\" + whitespace +\r\n                                \")\" + className + \"(\" + whitespace + \"|$)\" ) ) && classCache(\r\n                                className, function( elem ) {\r\n                                    return pattern.test(\r\n                                        typeof elem.className === \"string\" && elem.className ||\r\n                                        typeof elem.getAttribute !== \"undefined\" &&\r\n                                        elem.getAttribute( \"class\" ) ||\r\n                                        \"\"\r\n                                    );\r\n                                } );\r\n                    },\r\n\r\n                    \"ATTR\": function( name, operator, check ) {\r\n                        return function( elem ) {\r\n                            var result = Sizzle.attr( elem, name );\r\n\r\n                            if ( result == null ) {\r\n                                return operator === \"!=\";\r\n                            }\r\n                            if ( !operator ) {\r\n                                return true;\r\n                            }\r\n\r\n                            result += \"\";\r\n\r\n                            /* eslint-disable max-len */\r\n\r\n                            return operator === \"=\" ? result === check :\r\n                                operator === \"!=\" ? result !== check :\r\n                                    operator === \"^=\" ? check && result.indexOf( check ) === 0 :\r\n                                        operator === \"*=\" ? check && result.indexOf( check ) > -1 :\r\n                                            operator === \"$=\" ? check && result.slice( -check.length ) === check :\r\n                                                operator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\r\n                                                    operator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\r\n                                                        false;\r\n                            /* eslint-enable max-len */\r\n\r\n                        };\r\n                    },\r\n\r\n                    \"CHILD\": function( type, what, _argument, first, last ) {\r\n                        var simple = type.slice( 0, 3 ) !== \"nth\",\r\n                            forward = type.slice( -4 ) !== \"last\",\r\n                            ofType = what === \"of-type\";\r\n\r\n                        return first === 1 && last === 0 ?\r\n\r\n                            // Shortcut for :nth-*(n)\r\n                            function( elem ) {\r\n                                return !!elem.parentNode;\r\n                            } :\r\n\r\n                            function( elem, _context, xml ) {\r\n                                var cache, uniqueCache, outerCache, node, nodeIndex, start,\r\n                                    dir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\r\n                                    parent = elem.parentNode,\r\n                                    name = ofType && elem.nodeName.toLowerCase(),\r\n                                    useCache = !xml && !ofType,\r\n                                    diff = false;\r\n\r\n                                if ( parent ) {\r\n\r\n                                    // :(first|last|only)-(child|of-type)\r\n                                    if ( simple ) {\r\n                                        while ( dir ) {\r\n                                            node = elem;\r\n                                            while ( ( node = node[ dir ] ) ) {\r\n                                                if ( ofType ?\r\n                                                    node.nodeName.toLowerCase() === name :\r\n                                                    node.nodeType === 1 ) {\r\n\r\n                                                    return false;\r\n                                                }\r\n                                            }\r\n\r\n                                            // Reverse direction for :only-* (if we haven't yet done so)\r\n                                            start = dir = type === \"only\" && !start && \"nextSibling\";\r\n                                        }\r\n                                        return true;\r\n                                    }\r\n\r\n                                    start = [ forward ? parent.firstChild : parent.lastChild ];\r\n\r\n                                    // non-xml :nth-child(...) stores cache data on `parent`\r\n                                    if ( forward && useCache ) {\r\n\r\n                                        // Seek `elem` from a previously-cached index\r\n\r\n                                        // ...in a gzip-friendly way\r\n                                        node = parent;\r\n                                        outerCache = node[ expando ] || ( node[ expando ] = {} );\r\n\r\n                                        // Support: IE <9 only\r\n                                        // Defend against cloned attroperties (jQuery gh-1709)\r\n                                        uniqueCache = outerCache[ node.uniqueID ] ||\r\n                                            ( outerCache[ node.uniqueID ] = {} );\r\n\r\n                                        cache = uniqueCache[ type ] || [];\r\n                                        nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\r\n                                        diff = nodeIndex && cache[ 2 ];\r\n                                        node = nodeIndex && parent.childNodes[ nodeIndex ];\r\n\r\n                                        while ( ( node = ++nodeIndex && node && node[ dir ] ||\r\n\r\n                                            // Fallback to seeking `elem` from the start\r\n                                            ( diff = nodeIndex = 0 ) || start.pop() ) ) {\r\n\r\n                                            // When found, cache indexes on `parent` and break\r\n                                            if ( node.nodeType === 1 && ++diff && node === elem ) {\r\n                                                uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];\r\n                                                break;\r\n                                            }\r\n                                        }\r\n\r\n                                    } else {\r\n\r\n                                        // Use previously-cached element index if available\r\n                                        if ( useCache ) {\r\n\r\n                                            // ...in a gzip-friendly way\r\n                                            node = elem;\r\n                                            outerCache = node[ expando ] || ( node[ expando ] = {} );\r\n\r\n                                            // Support: IE <9 only\r\n                                            // Defend against cloned attroperties (jQuery gh-1709)\r\n                                            uniqueCache = outerCache[ node.uniqueID ] ||\r\n                                                ( outerCache[ node.uniqueID ] = {} );\r\n\r\n                                            cache = uniqueCache[ type ] || [];\r\n                                            nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\r\n                                            diff = nodeIndex;\r\n                                        }\r\n\r\n                                        // xml :nth-child(...)\r\n                                        // or :nth-last-child(...) or :nth(-last)?-of-type(...)\r\n                                        if ( diff === false ) {\r\n\r\n                                            // Use the same loop as above to seek `elem` from the start\r\n                                            while ( ( node = ++nodeIndex && node && node[ dir ] ||\r\n                                                ( diff = nodeIndex = 0 ) || start.pop() ) ) {\r\n\r\n                                                if ( ( ofType ?\r\n                                                        node.nodeName.toLowerCase() === name :\r\n                                                        node.nodeType === 1 ) &&\r\n                                                    ++diff ) {\r\n\r\n                                                    // Cache the index of each encountered element\r\n                                                    if ( useCache ) {\r\n                                                        outerCache = node[ expando ] ||\r\n                                                            ( node[ expando ] = {} );\r\n\r\n                                                        // Support: IE <9 only\r\n                                                        // Defend against cloned attroperties (jQuery gh-1709)\r\n                                                        uniqueCache = outerCache[ node.uniqueID ] ||\r\n                                                            ( outerCache[ node.uniqueID ] = {} );\r\n\r\n                                                        uniqueCache[ type ] = [ dirruns, diff ];\r\n                                                    }\r\n\r\n                                                    if ( node === elem ) {\r\n                                                        break;\r\n                                                    }\r\n                                                }\r\n                                            }\r\n                                        }\r\n                                    }\r\n\r\n                                    // Incorporate the offset, then check against cycle size\r\n                                    diff -= last;\r\n                                    return diff === first || ( diff % first === 0 && diff / first >= 0 );\r\n                                }\r\n                            };\r\n                    },\r\n\r\n                    \"PSEUDO\": function( pseudo, argument ) {\r\n\r\n                        // pseudo-class names are case-insensitive\r\n                        // http://www.w3.org/TR/selectors/#pseudo-classes\r\n                        // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\r\n                        // Remember that setFilters inherits from pseudos\r\n                        var args,\r\n                            fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\r\n                                Sizzle.error( \"unsupported pseudo: \" + pseudo );\r\n\r\n                        // The user may use createPseudo to indicate that\r\n                        // arguments are needed to create the filter function\r\n                        // just as Sizzle does\r\n                        if ( fn[ expando ] ) {\r\n                            return fn( argument );\r\n                        }\r\n\r\n                        // But maintain support for old signatures\r\n                        if ( fn.length > 1 ) {\r\n                            args = [ pseudo, pseudo, \"\", argument ];\r\n                            return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\r\n                                markFunction( function( seed, matches ) {\r\n                                    var idx,\r\n                                        matched = fn( seed, argument ),\r\n                                        i = matched.length;\r\n                                    while ( i-- ) {\r\n                                        idx = indexOf( seed, matched[ i ] );\r\n                                        seed[ idx ] = !( matches[ idx ] = matched[ i ] );\r\n                                    }\r\n                                } ) :\r\n                                function( elem ) {\r\n                                    return fn( elem, 0, args );\r\n                                };\r\n                        }\r\n\r\n                        return fn;\r\n                    }\r\n                },\r\n\r\n                pseudos: {\r\n\r\n                    // Potentially complex pseudos\r\n                    \"not\": markFunction( function( selector ) {\r\n\r\n                        // Trim the selector passed to compile\r\n                        // to avoid treating leading and trailing\r\n                        // spaces as combinators\r\n                        var input = [],\r\n                            results = [],\r\n                            matcher = compile( selector.replace( rtrim, \"$1\" ) );\r\n\r\n                        return matcher[ expando ] ?\r\n                            markFunction( function( seed, matches, _context, xml ) {\r\n                                var elem,\r\n                                    unmatched = matcher( seed, null, xml, [] ),\r\n                                    i = seed.length;\r\n\r\n                                // Match elements unmatched by `matcher`\r\n                                while ( i-- ) {\r\n                                    if ( ( elem = unmatched[ i ] ) ) {\r\n                                        seed[ i ] = !( matches[ i ] = elem );\r\n                                    }\r\n                                }\r\n                            } ) :\r\n                            function( elem, _context, xml ) {\r\n                                input[ 0 ] = elem;\r\n                                matcher( input, null, xml, results );\r\n\r\n                                // Don't keep the element (issue #299)\r\n                                input[ 0 ] = null;\r\n                                return !results.pop();\r\n                            };\r\n                    } ),\r\n\r\n                    \"has\": markFunction( function( selector ) {\r\n                        return function( elem ) {\r\n                            return Sizzle( selector, elem ).length > 0;\r\n                        };\r\n                    } ),\r\n\r\n                    \"contains\": markFunction( function( text ) {\r\n                        text = text.replace( runescape, funescape );\r\n                        return function( elem ) {\r\n                            return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;\r\n                        };\r\n                    } ),\r\n\r\n                    // \"Whether an element is represented by a :lang() selector\r\n                    // is based solely on the element's language value\r\n                    // being equal to the identifier C,\r\n                    // or beginning with the identifier C immediately followed by \"-\".\r\n                    // The matching of C against the element's language value is performed case-insensitively.\r\n                    // The identifier C does not have to be a valid language name.\"\r\n                    // http://www.w3.org/TR/selectors/#lang-pseudo\r\n                    \"lang\": markFunction( function( lang ) {\r\n\r\n                        // lang value must be a valid identifier\r\n                        if ( !ridentifier.test( lang || \"\" ) ) {\r\n                            Sizzle.error( \"unsupported lang: \" + lang );\r\n                        }\r\n                        lang = lang.replace( runescape, funescape ).toLowerCase();\r\n                        return function( elem ) {\r\n                            var elemLang;\r\n                            do {\r\n                                if ( ( elemLang = documentIsHTML ?\r\n                                    elem.lang :\r\n                                    elem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\r\n\r\n                                    elemLang = elemLang.toLowerCase();\r\n                                    return elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\r\n                                }\r\n                            } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\r\n                            return false;\r\n                        };\r\n                    } ),\r\n\r\n                    // Miscellaneous\r\n                    \"target\": function( elem ) {\r\n                        var hash = window.location && window.location.hash;\r\n                        return hash && hash.slice( 1 ) === elem.id;\r\n                    },\r\n\r\n                    \"root\": function( elem ) {\r\n                        return elem === docElem;\r\n                    },\r\n\r\n                    \"focus\": function( elem ) {\r\n                        return elem === document.activeElement &&\r\n                            ( !document.hasFocus || document.hasFocus() ) &&\r\n                            !!( elem.type || elem.href || ~elem.tabIndex );\r\n                    },\r\n\r\n                    // Boolean properties\r\n                    \"enabled\": createDisabledPseudo( false ),\r\n                    \"disabled\": createDisabledPseudo( true ),\r\n\r\n                    \"checked\": function( elem ) {\r\n\r\n                        // In CSS3, :checked should return both checked and selected elements\r\n                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\r\n                        var nodeName = elem.nodeName.toLowerCase();\r\n                        return ( nodeName === \"input\" && !!elem.checked ) ||\r\n                            ( nodeName === \"option\" && !!elem.selected );\r\n                    },\r\n\r\n                    \"selected\": function( elem ) {\r\n\r\n                        // Accessing this property makes selected-by-default\r\n                        // options in Safari work properly\r\n                        if ( elem.parentNode ) {\r\n                            // eslint-disable-next-line no-unused-expressions\r\n                            elem.parentNode.selectedIndex;\r\n                        }\r\n\r\n                        return elem.selected === true;\r\n                    },\r\n\r\n                    // Contents\r\n                    \"empty\": function( elem ) {\r\n\r\n                        // http://www.w3.org/TR/selectors/#empty-pseudo\r\n                        // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\r\n                        //   but not by others (comment: 8; processing instruction: 7; etc.)\r\n                        // nodeType < 6 works because attributes (2) do not appear as children\r\n                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\r\n                            if ( elem.nodeType < 6 ) {\r\n                                return false;\r\n                            }\r\n                        }\r\n                        return true;\r\n                    },\r\n\r\n                    \"parent\": function( elem ) {\r\n                        return !Expr.pseudos[ \"empty\" ]( elem );\r\n                    },\r\n\r\n                    // Element/input types\r\n                    \"header\": function( elem ) {\r\n                        return rheader.test( elem.nodeName );\r\n                    },\r\n\r\n                    \"input\": function( elem ) {\r\n                        return rinputs.test( elem.nodeName );\r\n                    },\r\n\r\n                    \"button\": function( elem ) {\r\n                        var name = elem.nodeName.toLowerCase();\r\n                        return name === \"input\" && elem.type === \"button\" || name === \"button\";\r\n                    },\r\n\r\n                    \"text\": function( elem ) {\r\n                        var attr;\r\n                        return elem.nodeName.toLowerCase() === \"input\" &&\r\n                            elem.type === \"text\" &&\r\n\r\n                            // Support: IE<8\r\n                            // New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\r\n                            ( ( attr = elem.getAttribute( \"type\" ) ) == null ||\r\n                                attr.toLowerCase() === \"text\" );\r\n                    },\r\n\r\n                    // Position-in-collection\r\n                    \"first\": createPositionalPseudo( function() {\r\n                        return [ 0 ];\r\n                    } ),\r\n\r\n                    \"last\": createPositionalPseudo( function( _matchIndexes, length ) {\r\n                        return [ length - 1 ];\r\n                    } ),\r\n\r\n                    \"eq\": createPositionalPseudo( function( _matchIndexes, length, argument ) {\r\n                        return [ argument < 0 ? argument + length : argument ];\r\n                    } ),\r\n\r\n                    \"even\": createPositionalPseudo( function( matchIndexes, length ) {\r\n                        var i = 0;\r\n                        for ( ; i < length; i += 2 ) {\r\n                            matchIndexes.push( i );\r\n                        }\r\n                        return matchIndexes;\r\n                    } ),\r\n\r\n                    \"odd\": createPositionalPseudo( function( matchIndexes, length ) {\r\n                        var i = 1;\r\n                        for ( ; i < length; i += 2 ) {\r\n                            matchIndexes.push( i );\r\n                        }\r\n                        return matchIndexes;\r\n                    } ),\r\n\r\n                    \"lt\": createPositionalPseudo( function( matchIndexes, length, argument ) {\r\n                        var i = argument < 0 ?\r\n                            argument + length :\r\n                            argument > length ?\r\n                                length :\r\n                                argument;\r\n                        for ( ; --i >= 0; ) {\r\n                            matchIndexes.push( i );\r\n                        }\r\n                        return matchIndexes;\r\n                    } ),\r\n\r\n                    \"gt\": createPositionalPseudo( function( matchIndexes, length, argument ) {\r\n                        var i = argument < 0 ? argument + length : argument;\r\n                        for ( ; ++i < length; ) {\r\n                            matchIndexes.push( i );\r\n                        }\r\n                        return matchIndexes;\r\n                    } )\r\n                }\r\n            };\r\n\r\n            Expr.pseudos[ \"nth\" ] = Expr.pseudos[ \"eq\" ];\r\n\r\n// Add button/input type pseudos\r\n            for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\r\n                Expr.pseudos[ i ] = createInputPseudo( i );\r\n            }\r\n            for ( i in { submit: true, reset: true } ) {\r\n                Expr.pseudos[ i ] = createButtonPseudo( i );\r\n            }\r\n\r\n// Easy API for creating new setFilters\r\n            function setFilters() {}\r\n            setFilters.prototype = Expr.filters = Expr.pseudos;\r\n            Expr.setFilters = new setFilters();\r\n\r\n            tokenize = Sizzle.tokenize = function( selector, parseOnly ) {\r\n                var matched, match, tokens, type,\r\n                    soFar, groups, preFilters,\r\n                    cached = tokenCache[ selector + \" \" ];\r\n\r\n                if ( cached ) {\r\n                    return parseOnly ? 0 : cached.slice( 0 );\r\n                }\r\n\r\n                soFar = selector;\r\n                groups = [];\r\n                preFilters = Expr.preFilter;\r\n\r\n                while ( soFar ) {\r\n\r\n                    // Comma and first run\r\n                    if ( !matched || ( match = rcomma.exec( soFar ) ) ) {\r\n                        if ( match ) {\r\n\r\n                            // Don't consume trailing commas as valid\r\n                            soFar = soFar.slice( match[ 0 ].length ) || soFar;\r\n                        }\r\n                        groups.push( ( tokens = [] ) );\r\n                    }\r\n\r\n                    matched = false;\r\n\r\n                    // Combinators\r\n                    if ( ( match = rcombinators.exec( soFar ) ) ) {\r\n                        matched = match.shift();\r\n                        tokens.push( {\r\n                            value: matched,\r\n\r\n                            // Cast descendant combinators to space\r\n                            type: match[ 0 ].replace( rtrim, \" \" )\r\n                        } );\r\n                        soFar = soFar.slice( matched.length );\r\n                    }\r\n\r\n                    // Filters\r\n                    for ( type in Expr.filter ) {\r\n                        if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\r\n                            ( match = preFilters[ type ]( match ) ) ) ) {\r\n                            matched = match.shift();\r\n                            tokens.push( {\r\n                                value: matched,\r\n                                type: type,\r\n                                matches: match\r\n                            } );\r\n                            soFar = soFar.slice( matched.length );\r\n                        }\r\n                    }\r\n\r\n                    if ( !matched ) {\r\n                        break;\r\n                    }\r\n                }\r\n\r\n                // Return the length of the invalid excess\r\n                // if we're just parsing\r\n                // Otherwise, throw an error or return tokens\r\n                return parseOnly ?\r\n                    soFar.length :\r\n                    soFar ?\r\n                        Sizzle.error( selector ) :\r\n\r\n                        // Cache the tokens\r\n                        tokenCache( selector, groups ).slice( 0 );\r\n            };\r\n\r\n            function toSelector( tokens ) {\r\n                var i = 0,\r\n                    len = tokens.length,\r\n                    selector = \"\";\r\n                for ( ; i < len; i++ ) {\r\n                    selector += tokens[ i ].value;\r\n                }\r\n                return selector;\r\n            }\r\n\r\n            function addCombinator( matcher, combinator, base ) {\r\n                var dir = combinator.dir,\r\n                    skip = combinator.next,\r\n                    key = skip || dir,\r\n                    checkNonElements = base && key === \"parentNode\",\r\n                    doneName = done++;\r\n\r\n                return combinator.first ?\r\n\r\n                    // Check against closest ancestor/preceding element\r\n                    function( elem, context, xml ) {\r\n                        while ( ( elem = elem[ dir ] ) ) {\r\n                            if ( elem.nodeType === 1 || checkNonElements ) {\r\n                                return matcher( elem, context, xml );\r\n                            }\r\n                        }\r\n                        return false;\r\n                    } :\r\n\r\n                    // Check against all ancestor/preceding elements\r\n                    function( elem, context, xml ) {\r\n                        var oldCache, uniqueCache, outerCache,\r\n                            newCache = [ dirruns, doneName ];\r\n\r\n                        // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\r\n                        if ( xml ) {\r\n                            while ( ( elem = elem[ dir ] ) ) {\r\n                                if ( elem.nodeType === 1 || checkNonElements ) {\r\n                                    if ( matcher( elem, context, xml ) ) {\r\n                                        return true;\r\n                                    }\r\n                                }\r\n                            }\r\n                        } else {\r\n                            while ( ( elem = elem[ dir ] ) ) {\r\n                                if ( elem.nodeType === 1 || checkNonElements ) {\r\n                                    outerCache = elem[ expando ] || ( elem[ expando ] = {} );\r\n\r\n                                    // Support: IE <9 only\r\n                                    // Defend against cloned attroperties (jQuery gh-1709)\r\n                                    uniqueCache = outerCache[ elem.uniqueID ] ||\r\n                                        ( outerCache[ elem.uniqueID ] = {} );\r\n\r\n                                    if ( skip && skip === elem.nodeName.toLowerCase() ) {\r\n                                        elem = elem[ dir ] || elem;\r\n                                    } else if ( ( oldCache = uniqueCache[ key ] ) &&\r\n                                        oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\r\n\r\n                                        // Assign to newCache so results back-propagate to previous elements\r\n                                        return ( newCache[ 2 ] = oldCache[ 2 ] );\r\n                                    } else {\r\n\r\n                                        // Reuse newcache so results back-propagate to previous elements\r\n                                        uniqueCache[ key ] = newCache;\r\n\r\n                                        // A match means we're done; a fail means we have to keep checking\r\n                                        if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\r\n                                            return true;\r\n                                        }\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                        return false;\r\n                    };\r\n            }\r\n\r\n            function elementMatcher( matchers ) {\r\n                return matchers.length > 1 ?\r\n                    function( elem, context, xml ) {\r\n                        var i = matchers.length;\r\n                        while ( i-- ) {\r\n                            if ( !matchers[ i ]( elem, context, xml ) ) {\r\n                                return false;\r\n                            }\r\n                        }\r\n                        return true;\r\n                    } :\r\n                    matchers[ 0 ];\r\n            }\r\n\r\n            function multipleContexts( selector, contexts, results ) {\r\n                var i = 0,\r\n                    len = contexts.length;\r\n                for ( ; i < len; i++ ) {\r\n                    Sizzle( selector, contexts[ i ], results );\r\n                }\r\n                return results;\r\n            }\r\n\r\n            function condense( unmatched, map, filter, context, xml ) {\r\n                var elem,\r\n                    newUnmatched = [],\r\n                    i = 0,\r\n                    len = unmatched.length,\r\n                    mapped = map != null;\r\n\r\n                for ( ; i < len; i++ ) {\r\n                    if ( ( elem = unmatched[ i ] ) ) {\r\n                        if ( !filter || filter( elem, context, xml ) ) {\r\n                            newUnmatched.push( elem );\r\n                            if ( mapped ) {\r\n                                map.push( i );\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n\r\n                return newUnmatched;\r\n            }\r\n\r\n            function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\r\n                if ( postFilter && !postFilter[ expando ] ) {\r\n                    postFilter = setMatcher( postFilter );\r\n                }\r\n                if ( postFinder && !postFinder[ expando ] ) {\r\n                    postFinder = setMatcher( postFinder, postSelector );\r\n                }\r\n                return markFunction( function( seed, results, context, xml ) {\r\n                    var temp, i, elem,\r\n                        preMap = [],\r\n                        postMap = [],\r\n                        preexisting = results.length,\r\n\r\n                        // Get initial elements from seed or context\r\n                        elems = seed || multipleContexts(\r\n                            selector || \"*\",\r\n                            context.nodeType ? [ context ] : context,\r\n                            []\r\n                        ),\r\n\r\n                        // Prefilter to get matcher input, preserving a map for seed-results synchronization\r\n                        matcherIn = preFilter && ( seed || !selector ) ?\r\n                            condense( elems, preMap, preFilter, context, xml ) :\r\n                            elems,\r\n\r\n                        matcherOut = matcher ?\r\n\r\n                            // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\r\n                            postFinder || ( seed ? preFilter : preexisting || postFilter ) ?\r\n\r\n                                // ...intermediate processing is necessary\r\n                                [] :\r\n\r\n                                // ...otherwise use results directly\r\n                                results :\r\n                            matcherIn;\r\n\r\n                    // Find primary matches\r\n                    if ( matcher ) {\r\n                        matcher( matcherIn, matcherOut, context, xml );\r\n                    }\r\n\r\n                    // Apply postFilter\r\n                    if ( postFilter ) {\r\n                        temp = condense( matcherOut, postMap );\r\n                        postFilter( temp, [], context, xml );\r\n\r\n                        // Un-match failing elements by moving them back to matcherIn\r\n                        i = temp.length;\r\n                        while ( i-- ) {\r\n                            if ( ( elem = temp[ i ] ) ) {\r\n                                matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    if ( seed ) {\r\n                        if ( postFinder || preFilter ) {\r\n                            if ( postFinder ) {\r\n\r\n                                // Get the final matcherOut by condensing this intermediate into postFinder contexts\r\n                                temp = [];\r\n                                i = matcherOut.length;\r\n                                while ( i-- ) {\r\n                                    if ( ( elem = matcherOut[ i ] ) ) {\r\n\r\n                                        // Restore matcherIn since elem is not yet a final match\r\n                                        temp.push( ( matcherIn[ i ] = elem ) );\r\n                                    }\r\n                                }\r\n                                postFinder( null, ( matcherOut = [] ), temp, xml );\r\n                            }\r\n\r\n                            // Move matched elements from seed to results to keep them synchronized\r\n                            i = matcherOut.length;\r\n                            while ( i-- ) {\r\n                                if ( ( elem = matcherOut[ i ] ) &&\r\n                                    ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {\r\n\r\n                                    seed[ temp ] = !( results[ temp ] = elem );\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        // Add elements to results, through postFinder if defined\r\n                    } else {\r\n                        matcherOut = condense(\r\n                            matcherOut === results ?\r\n                                matcherOut.splice( preexisting, matcherOut.length ) :\r\n                                matcherOut\r\n                        );\r\n                        if ( postFinder ) {\r\n                            postFinder( null, results, matcherOut, xml );\r\n                        } else {\r\n                            push.apply( results, matcherOut );\r\n                        }\r\n                    }\r\n                } );\r\n            }\r\n\r\n            function matcherFromTokens( tokens ) {\r\n                var checkContext, matcher, j,\r\n                    len = tokens.length,\r\n                    leadingRelative = Expr.relative[ tokens[ 0 ].type ],\r\n                    implicitRelative = leadingRelative || Expr.relative[ \" \" ],\r\n                    i = leadingRelative ? 1 : 0,\r\n\r\n                    // The foundational matcher ensures that elements are reachable from top-level context(s)\r\n                    matchContext = addCombinator( function( elem ) {\r\n                        return elem === checkContext;\r\n                    }, implicitRelative, true ),\r\n                    matchAnyContext = addCombinator( function( elem ) {\r\n                        return indexOf( checkContext, elem ) > -1;\r\n                    }, implicitRelative, true ),\r\n                    matchers = [ function( elem, context, xml ) {\r\n                        var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\r\n                            ( checkContext = context ).nodeType ?\r\n                                matchContext( elem, context, xml ) :\r\n                                matchAnyContext( elem, context, xml ) );\r\n\r\n                        // Avoid hanging onto element (issue #299)\r\n                        checkContext = null;\r\n                        return ret;\r\n                    } ];\r\n\r\n                for ( ; i < len; i++ ) {\r\n                    if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {\r\n                        matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\r\n                    } else {\r\n                        matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\r\n\r\n                        // Return special upon seeing a positional matcher\r\n                        if ( matcher[ expando ] ) {\r\n\r\n                            // Find the next relative operator (if any) for proper handling\r\n                            j = ++i;\r\n                            for ( ; j < len; j++ ) {\r\n                                if ( Expr.relative[ tokens[ j ].type ] ) {\r\n                                    break;\r\n                                }\r\n                            }\r\n                            return setMatcher(\r\n                                i > 1 && elementMatcher( matchers ),\r\n                                i > 1 && toSelector(\r\n\r\n                                    // If the preceding token was a descendant combinator, insert an implicit any-element `*`\r\n                                    tokens\r\n                                        .slice( 0, i - 1 )\r\n                                        .concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\r\n                                ).replace( rtrim, \"$1\" ),\r\n                                matcher,\r\n                                i < j && matcherFromTokens( tokens.slice( i, j ) ),\r\n                                j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\r\n                                j < len && toSelector( tokens )\r\n                            );\r\n                        }\r\n                        matchers.push( matcher );\r\n                    }\r\n                }\r\n\r\n                return elementMatcher( matchers );\r\n            }\r\n\r\n            function matcherFromGroupMatchers( elementMatchers, setMatchers ) {\r\n                var bySet = setMatchers.length > 0,\r\n                    byElement = elementMatchers.length > 0,\r\n                    superMatcher = function( seed, context, xml, results, outermost ) {\r\n                        var elem, j, matcher,\r\n                            matchedCount = 0,\r\n                            i = \"0\",\r\n                            unmatched = seed && [],\r\n                            setMatched = [],\r\n                            contextBackup = outermostContext,\r\n\r\n                            // We must always have either seed elements or outermost context\r\n                            elems = seed || byElement && Expr.find[ \"TAG\" ]( \"*\", outermost ),\r\n\r\n                            // Use integer dirruns iff this is the outermost matcher\r\n                            dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),\r\n                            len = elems.length;\r\n\r\n                        if ( outermost ) {\r\n\r\n                            // Support: IE 11+, Edge 17 - 18+\r\n                            // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                            // two documents; shallow comparisons work.\r\n                            // eslint-disable-next-line eqeqeq\r\n                            outermostContext = context == document || context || outermost;\r\n                        }\r\n\r\n                        // Add elements passing elementMatchers directly to results\r\n                        // Support: IE<9, Safari\r\n                        // Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\r\n                        for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {\r\n                            if ( byElement && elem ) {\r\n                                j = 0;\r\n\r\n                                // Support: IE 11+, Edge 17 - 18+\r\n                                // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\r\n                                // two documents; shallow comparisons work.\r\n                                // eslint-disable-next-line eqeqeq\r\n                                if ( !context && elem.ownerDocument != document ) {\r\n                                    setDocument( elem );\r\n                                    xml = !documentIsHTML;\r\n                                }\r\n                                while ( ( matcher = elementMatchers[ j++ ] ) ) {\r\n                                    if ( matcher( elem, context || document, xml ) ) {\r\n                                        results.push( elem );\r\n                                        break;\r\n                                    }\r\n                                }\r\n                                if ( outermost ) {\r\n                                    dirruns = dirrunsUnique;\r\n                                }\r\n                            }\r\n\r\n                            // Track unmatched elements for set filters\r\n                            if ( bySet ) {\r\n\r\n                                // They will have gone through all possible matchers\r\n                                if ( ( elem = !matcher && elem ) ) {\r\n                                    matchedCount--;\r\n                                }\r\n\r\n                                // Lengthen the array for every element, matched or not\r\n                                if ( seed ) {\r\n                                    unmatched.push( elem );\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        // `i` is now the count of elements visited above, and adding it to `matchedCount`\r\n                        // makes the latter nonnegative.\r\n                        matchedCount += i;\r\n\r\n                        // Apply set filters to unmatched elements\r\n                        // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\r\n                        // equals `i`), unless we didn't visit _any_ elements in the above loop because we have\r\n                        // no element matchers and no seed.\r\n                        // Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\r\n                        // case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\r\n                        // numerically zero.\r\n                        if ( bySet && i !== matchedCount ) {\r\n                            j = 0;\r\n                            while ( ( matcher = setMatchers[ j++ ] ) ) {\r\n                                matcher( unmatched, setMatched, context, xml );\r\n                            }\r\n\r\n                            if ( seed ) {\r\n\r\n                                // Reintegrate element matches to eliminate the need for sorting\r\n                                if ( matchedCount > 0 ) {\r\n                                    while ( i-- ) {\r\n                                        if ( !( unmatched[ i ] || setMatched[ i ] ) ) {\r\n                                            setMatched[ i ] = pop.call( results );\r\n                                        }\r\n                                    }\r\n                                }\r\n\r\n                                // Discard index placeholder values to get only actual matches\r\n                                setMatched = condense( setMatched );\r\n                            }\r\n\r\n                            // Add matches to results\r\n                            push.apply( results, setMatched );\r\n\r\n                            // Seedless set matches succeeding multiple successful matchers stipulate sorting\r\n                            if ( outermost && !seed && setMatched.length > 0 &&\r\n                                ( matchedCount + setMatchers.length ) > 1 ) {\r\n\r\n                                Sizzle.uniqueSort( results );\r\n                            }\r\n                        }\r\n\r\n                        // Override manipulation of globals by nested matchers\r\n                        if ( outermost ) {\r\n                            dirruns = dirrunsUnique;\r\n                            outermostContext = contextBackup;\r\n                        }\r\n\r\n                        return unmatched;\r\n                    };\r\n\r\n                return bySet ?\r\n                    markFunction( superMatcher ) :\r\n                    superMatcher;\r\n            }\r\n\r\n            compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\r\n                var i,\r\n                    setMatchers = [],\r\n                    elementMatchers = [],\r\n                    cached = compilerCache[ selector + \" \" ];\r\n\r\n                if ( !cached ) {\r\n\r\n                    // Generate a function of recursive functions that can be used to check each element\r\n                    if ( !match ) {\r\n                        match = tokenize( selector );\r\n                    }\r\n                    i = match.length;\r\n                    while ( i-- ) {\r\n                        cached = matcherFromTokens( match[ i ] );\r\n                        if ( cached[ expando ] ) {\r\n                            setMatchers.push( cached );\r\n                        } else {\r\n                            elementMatchers.push( cached );\r\n                        }\r\n                    }\r\n\r\n                    // Cache the compiled function\r\n                    cached = compilerCache(\r\n                        selector,\r\n                        matcherFromGroupMatchers( elementMatchers, setMatchers )\r\n                    );\r\n\r\n                    // Save selector and tokenization\r\n                    cached.selector = selector;\r\n                }\r\n                return cached;\r\n            };\r\n\r\n            /**\r\n             * A low-level selection function that works with Sizzle's compiled\r\n             *  selector functions\r\n             * @param {String|Function} selector A selector or a pre-compiled\r\n             *  selector function built with Sizzle.compile\r\n             * @param {Element} context\r\n             * @param {Array} [results]\r\n             * @param {Array} [seed] A set of elements to match against\r\n             */\r\n            select = Sizzle.select = function( selector, context, results, seed ) {\r\n                var i, tokens, token, type, find,\r\n                    compiled = typeof selector === \"function\" && selector,\r\n                    match = !seed && tokenize( ( selector = compiled.selector || selector ) );\r\n\r\n                results = results || [];\r\n\r\n                // Try to minimize operations if there is only one selector in the list and no seed\r\n                // (the latter of which guarantees us context)\r\n                if ( match.length === 1 ) {\r\n\r\n                    // Reduce context if the leading compound selector is an ID\r\n                    tokens = match[ 0 ] = match[ 0 ].slice( 0 );\r\n                    if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\r\n                        context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\r\n\r\n                        context = ( Expr.find[ \"ID\" ]( token.matches[ 0 ]\r\n                            .replace( runescape, funescape ), context ) || [] )[ 0 ];\r\n                        if ( !context ) {\r\n                            return results;\r\n\r\n                            // Precompiled matchers will still verify ancestry, so step up a level\r\n                        } else if ( compiled ) {\r\n                            context = context.parentNode;\r\n                        }\r\n\r\n                        selector = selector.slice( tokens.shift().value.length );\r\n                    }\r\n\r\n                    // Fetch a seed set for right-to-left matching\r\n                    i = matchExpr[ \"needsContext\" ].test( selector ) ? 0 : tokens.length;\r\n                    while ( i-- ) {\r\n                        token = tokens[ i ];\r\n\r\n                        // Abort if we hit a combinator\r\n                        if ( Expr.relative[ ( type = token.type ) ] ) {\r\n                            break;\r\n                        }\r\n                        if ( ( find = Expr.find[ type ] ) ) {\r\n\r\n                            // Search, expanding context for leading sibling combinators\r\n                            if ( ( seed = find(\r\n                                token.matches[ 0 ].replace( runescape, funescape ),\r\n                                rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||\r\n                                context\r\n                            ) ) ) {\r\n\r\n                                // If seed is empty or no tokens remain, we can return early\r\n                                tokens.splice( i, 1 );\r\n                                selector = seed.length && toSelector( tokens );\r\n                                if ( !selector ) {\r\n                                    push.apply( results, seed );\r\n                                    return results;\r\n                                }\r\n\r\n                                break;\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // Compile and execute a filtering function if one is not provided\r\n                // Provide `match` to avoid retokenization if we modified the selector above\r\n                ( compiled || compile( selector, match ) )(\r\n                    seed,\r\n                    context,\r\n                    !documentIsHTML,\r\n                    results,\r\n                    !context || rsibling.test( selector ) && testContext( context.parentNode ) || context\r\n                );\r\n                return results;\r\n            };\r\n\r\n// One-time assignments\r\n\r\n// Sort stability\r\n            support.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\r\n\r\n// Support: Chrome 14-35+\r\n// Always assume duplicates if they aren't passed to the comparison function\r\n            support.detectDuplicates = !!hasDuplicate;\r\n\r\n// Initialize against the default document\r\n            setDocument();\r\n\r\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\r\n// Detached nodes confoundingly follow *each other*\r\n            support.sortDetached = assert( function( el ) {\r\n\r\n                // Should return 1, but returns 4 (following)\r\n                return el.compareDocumentPosition( document.createElement( \"fieldset\" ) ) & 1;\r\n            } );\r\n\r\n// Support: IE<8\r\n// Prevent attribute/property \"interpolation\"\r\n// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\r\n            if ( !assert( function( el ) {\r\n                el.innerHTML = \"<a href='#'></a>\";\r\n                return el.firstChild.getAttribute( \"href\" ) === \"#\";\r\n            } ) ) {\r\n                addHandle( \"type|href|height|width\", function( elem, name, isXML ) {\r\n                    if ( !isXML ) {\r\n                        return elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\r\n                    }\r\n                } );\r\n            }\r\n\r\n// Support: IE<9\r\n// Use defaultValue in place of getAttribute(\"value\")\r\n            if ( !support.attributes || !assert( function( el ) {\r\n                el.innerHTML = \"<input/>\";\r\n                el.firstChild.setAttribute( \"value\", \"\" );\r\n                return el.firstChild.getAttribute( \"value\" ) === \"\";\r\n            } ) ) {\r\n                addHandle( \"value\", function( elem, _name, isXML ) {\r\n                    if ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\r\n                        return elem.defaultValue;\r\n                    }\r\n                } );\r\n            }\r\n\r\n// Support: IE<9\r\n// Use getAttributeNode to fetch booleans when getAttribute lies\r\n            if ( !assert( function( el ) {\r\n                return el.getAttribute( \"disabled\" ) == null;\r\n            } ) ) {\r\n                addHandle( booleans, function( elem, name, isXML ) {\r\n                    var val;\r\n                    if ( !isXML ) {\r\n                        return elem[ name ] === true ? name.toLowerCase() :\r\n                            ( val = elem.getAttributeNode( name ) ) && val.specified ?\r\n                                val.value :\r\n                                null;\r\n                    }\r\n                } );\r\n            }\r\n\r\n            return Sizzle;\r\n\r\n        } )( window );\r\n\r\n\r\n\r\n    jQuery.find = Sizzle;\r\n    jQuery.expr = Sizzle.selectors;\r\n\r\n// Deprecated\r\n    jQuery.expr[ \":\" ] = jQuery.expr.pseudos;\r\n    jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\r\n    jQuery.text = Sizzle.getText;\r\n    jQuery.isXMLDoc = Sizzle.isXML;\r\n    jQuery.contains = Sizzle.contains;\r\n    jQuery.escapeSelector = Sizzle.escape;\r\n\r\n\r\n\r\n\r\n    var dir = function( elem, dir, until ) {\r\n        var matched = [],\r\n            truncate = until !== undefined;\r\n\r\n        while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\r\n            if ( elem.nodeType === 1 ) {\r\n                if ( truncate && jQuery( elem ).is( until ) ) {\r\n                    break;\r\n                }\r\n                matched.push( elem );\r\n            }\r\n        }\r\n        return matched;\r\n    };\r\n\r\n\r\n    var siblings = function( n, elem ) {\r\n        var matched = [];\r\n\r\n        for ( ; n; n = n.nextSibling ) {\r\n            if ( n.nodeType === 1 && n !== elem ) {\r\n                matched.push( n );\r\n            }\r\n        }\r\n\r\n        return matched;\r\n    };\r\n\r\n\r\n    var rneedsContext = jQuery.expr.match.needsContext;\r\n\r\n\r\n\r\n    function nodeName( elem, name ) {\r\n\r\n        return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\r\n\r\n    }\r\n    var rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\r\n\r\n\r\n\r\n// Implement the identical functionality for filter and not\r\n    function winnow( elements, qualifier, not ) {\r\n        if ( isFunction( qualifier ) ) {\r\n            return jQuery.grep( elements, function( elem, i ) {\r\n                return !!qualifier.call( elem, i, elem ) !== not;\r\n            } );\r\n        }\r\n\r\n        // Single element\r\n        if ( qualifier.nodeType ) {\r\n            return jQuery.grep( elements, function( elem ) {\r\n                return ( elem === qualifier ) !== not;\r\n            } );\r\n        }\r\n\r\n        // Arraylike of elements (jQuery, arguments, Array)\r\n        if ( typeof qualifier !== \"string\" ) {\r\n            return jQuery.grep( elements, function( elem ) {\r\n                return ( indexOf.call( qualifier, elem ) > -1 ) !== not;\r\n            } );\r\n        }\r\n\r\n        // Filtered directly for both simple and complex selectors\r\n        return jQuery.filter( qualifier, elements, not );\r\n    }\r\n\r\n    jQuery.filter = function( expr, elems, not ) {\r\n        var elem = elems[ 0 ];\r\n\r\n        if ( not ) {\r\n            expr = \":not(\" + expr + \")\";\r\n        }\r\n\r\n        if ( elems.length === 1 && elem.nodeType === 1 ) {\r\n            return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\r\n        }\r\n\r\n        return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\r\n            return elem.nodeType === 1;\r\n        } ) );\r\n    };\r\n\r\n    jQuery.fn.extend( {\r\n        find: function( selector ) {\r\n            var i, ret,\r\n                len = this.length,\r\n                self = this;\r\n\r\n            if ( typeof selector !== \"string\" ) {\r\n                return this.pushStack( jQuery( selector ).filter( function() {\r\n                    for ( i = 0; i < len; i++ ) {\r\n                        if ( jQuery.contains( self[ i ], this ) ) {\r\n                            return true;\r\n                        }\r\n                    }\r\n                } ) );\r\n            }\r\n\r\n            ret = this.pushStack( [] );\r\n\r\n            for ( i = 0; i < len; i++ ) {\r\n                jQuery.find( selector, self[ i ], ret );\r\n            }\r\n\r\n            return len > 1 ? jQuery.uniqueSort( ret ) : ret;\r\n        },\r\n        filter: function( selector ) {\r\n            return this.pushStack( winnow( this, selector || [], false ) );\r\n        },\r\n        not: function( selector ) {\r\n            return this.pushStack( winnow( this, selector || [], true ) );\r\n        },\r\n        is: function( selector ) {\r\n            return !!winnow(\r\n                this,\r\n\r\n                // If this is a positional/relative selector, check membership in the returned set\r\n                // so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\r\n                typeof selector === \"string\" && rneedsContext.test( selector ) ?\r\n                    jQuery( selector ) :\r\n                    selector || [],\r\n                false\r\n            ).length;\r\n        }\r\n    } );\r\n\r\n\r\n// Initialize a jQuery object\r\n\r\n\r\n// A central reference to the root jQuery(document)\r\n    var rootjQuery,\r\n\r\n        // A simple way to check for HTML strings\r\n        // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\r\n        // Strict HTML recognition (#11290: must start with <)\r\n        // Shortcut simple #id case for speed\r\n        rquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\r\n\r\n        init = jQuery.fn.init = function( selector, context, root ) {\r\n            var match, elem;\r\n\r\n            // HANDLE: $(\"\"), $(null), $(undefined), $(false)\r\n            if ( !selector ) {\r\n                return this;\r\n            }\r\n\r\n            // Method init() accepts an alternate rootjQuery\r\n            // so migrate can support jQuery.sub (gh-2101)\r\n            root = root || rootjQuery;\r\n\r\n            // Handle HTML strings\r\n            if ( typeof selector === \"string\" ) {\r\n                if ( selector[ 0 ] === \"<\" &&\r\n                    selector[ selector.length - 1 ] === \">\" &&\r\n                    selector.length >= 3 ) {\r\n\r\n                    // Assume that strings that start and end with <> are HTML and skip the regex check\r\n                    match = [ null, selector, null ];\r\n\r\n                } else {\r\n                    match = rquickExpr.exec( selector );\r\n                }\r\n\r\n                // Match html or make sure no context is specified for #id\r\n                if ( match && ( match[ 1 ] || !context ) ) {\r\n\r\n                    // HANDLE: $(html) -> $(array)\r\n                    if ( match[ 1 ] ) {\r\n                        context = context instanceof jQuery ? context[ 0 ] : context;\r\n\r\n                        // Option to run scripts is true for back-compat\r\n                        // Intentionally let the error be thrown if parseHTML is not present\r\n                        jQuery.merge( this, jQuery.parseHTML(\r\n                            match[ 1 ],\r\n                            context && context.nodeType ? context.ownerDocument || context : document,\r\n                            true\r\n                        ) );\r\n\r\n                        // HANDLE: $(html, props)\r\n                        if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\r\n                            for ( match in context ) {\r\n\r\n                                // Properties of context are called as methods if possible\r\n                                if ( isFunction( this[ match ] ) ) {\r\n                                    this[ match ]( context[ match ] );\r\n\r\n                                    // ...and otherwise set as attributes\r\n                                } else {\r\n                                    this.attr( match, context[ match ] );\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        return this;\r\n\r\n                        // HANDLE: $(#id)\r\n                    } else {\r\n                        elem = document.getElementById( match[ 2 ] );\r\n\r\n                        if ( elem ) {\r\n\r\n                            // Inject the element directly into the jQuery object\r\n                            this[ 0 ] = elem;\r\n                            this.length = 1;\r\n                        }\r\n                        return this;\r\n                    }\r\n\r\n                    // HANDLE: $(expr, $(...))\r\n                } else if ( !context || context.jquery ) {\r\n                    return ( context || root ).find( selector );\r\n\r\n                    // HANDLE: $(expr, context)\r\n                    // (which is just equivalent to: $(context).find(expr)\r\n                } else {\r\n                    return this.constructor( context ).find( selector );\r\n                }\r\n\r\n                // HANDLE: $(DOMElement)\r\n            } else if ( selector.nodeType ) {\r\n                this[ 0 ] = selector;\r\n                this.length = 1;\r\n                return this;\r\n\r\n                // HANDLE: $(function)\r\n                // Shortcut for document ready\r\n            } else if ( isFunction( selector ) ) {\r\n                return root.ready !== undefined ?\r\n                    root.ready( selector ) :\r\n\r\n                    // Execute immediately if ready is not present\r\n                    selector( jQuery );\r\n            }\r\n\r\n            return jQuery.makeArray( selector, this );\r\n        };\r\n\r\n// Give the init function the jQuery prototype for later instantiation\r\n    init.prototype = jQuery.fn;\r\n\r\n// Initialize central reference\r\n    rootjQuery = jQuery( document );\r\n\r\n\r\n    var rparentsprev = /^(?:parents|prev(?:Until|All))/,\r\n\r\n        // Methods guaranteed to produce a unique set when starting from a unique set\r\n        guaranteedUnique = {\r\n            children: true,\r\n            contents: true,\r\n            next: true,\r\n            prev: true\r\n        };\r\n\r\n    jQuery.fn.extend( {\r\n        has: function( target ) {\r\n            var targets = jQuery( target, this ),\r\n                l = targets.length;\r\n\r\n            return this.filter( function() {\r\n                var i = 0;\r\n                for ( ; i < l; i++ ) {\r\n                    if ( jQuery.contains( this, targets[ i ] ) ) {\r\n                        return true;\r\n                    }\r\n                }\r\n            } );\r\n        },\r\n\r\n        closest: function( selectors, context ) {\r\n            var cur,\r\n                i = 0,\r\n                l = this.length,\r\n                matched = [],\r\n                targets = typeof selectors !== \"string\" && jQuery( selectors );\r\n\r\n            // Positional selectors never match, since there's no _selection_ context\r\n            if ( !rneedsContext.test( selectors ) ) {\r\n                for ( ; i < l; i++ ) {\r\n                    for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\r\n\r\n                        // Always skip document fragments\r\n                        if ( cur.nodeType < 11 && ( targets ?\r\n                            targets.index( cur ) > -1 :\r\n\r\n                            // Don't pass non-elements to Sizzle\r\n                            cur.nodeType === 1 &&\r\n                            jQuery.find.matchesSelector( cur, selectors ) ) ) {\r\n\r\n                            matched.push( cur );\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\r\n        },\r\n\r\n        // Determine the position of an element within the set\r\n        index: function( elem ) {\r\n\r\n            // No argument, return index in parent\r\n            if ( !elem ) {\r\n                return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\r\n            }\r\n\r\n            // Index in selector\r\n            if ( typeof elem === \"string\" ) {\r\n                return indexOf.call( jQuery( elem ), this[ 0 ] );\r\n            }\r\n\r\n            // Locate the position of the desired element\r\n            return indexOf.call( this,\r\n\r\n                // If it receives a jQuery object, the first element is used\r\n                elem.jquery ? elem[ 0 ] : elem\r\n            );\r\n        },\r\n\r\n        add: function( selector, context ) {\r\n            return this.pushStack(\r\n                jQuery.uniqueSort(\r\n                    jQuery.merge( this.get(), jQuery( selector, context ) )\r\n                )\r\n            );\r\n        },\r\n\r\n        addBack: function( selector ) {\r\n            return this.add( selector == null ?\r\n                this.prevObject : this.prevObject.filter( selector )\r\n            );\r\n        }\r\n    } );\r\n\r\n    function sibling( cur, dir ) {\r\n        while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\r\n        return cur;\r\n    }\r\n\r\n    jQuery.each( {\r\n        parent: function( elem ) {\r\n            var parent = elem.parentNode;\r\n            return parent && parent.nodeType !== 11 ? parent : null;\r\n        },\r\n        parents: function( elem ) {\r\n            return dir( elem, \"parentNode\" );\r\n        },\r\n        parentsUntil: function( elem, _i, until ) {\r\n            return dir( elem, \"parentNode\", until );\r\n        },\r\n        next: function( elem ) {\r\n            return sibling( elem, \"nextSibling\" );\r\n        },\r\n        prev: function( elem ) {\r\n            return sibling( elem, \"previousSibling\" );\r\n        },\r\n        nextAll: function( elem ) {\r\n            return dir( elem, \"nextSibling\" );\r\n        },\r\n        prevAll: function( elem ) {\r\n            return dir( elem, \"previousSibling\" );\r\n        },\r\n        nextUntil: function( elem, _i, until ) {\r\n            return dir( elem, \"nextSibling\", until );\r\n        },\r\n        prevUntil: function( elem, _i, until ) {\r\n            return dir( elem, \"previousSibling\", until );\r\n        },\r\n        siblings: function( elem ) {\r\n            return siblings( ( elem.parentNode || {} ).firstChild, elem );\r\n        },\r\n        children: function( elem ) {\r\n            return siblings( elem.firstChild );\r\n        },\r\n        contents: function( elem ) {\r\n            if ( elem.contentDocument != null &&\r\n\r\n                // Support: IE 11+\r\n                // <object> elements with no `data` attribute has an object\r\n                // `contentDocument` with a `null` prototype.\r\n                getProto( elem.contentDocument ) ) {\r\n\r\n                return elem.contentDocument;\r\n            }\r\n\r\n            // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\r\n            // Treat the template element as a regular one in browsers that\r\n            // don't support it.\r\n            if ( nodeName( elem, \"template\" ) ) {\r\n                elem = elem.content || elem;\r\n            }\r\n\r\n            return jQuery.merge( [], elem.childNodes );\r\n        }\r\n    }, function( name, fn ) {\r\n        jQuery.fn[ name ] = function( until, selector ) {\r\n            var matched = jQuery.map( this, fn, until );\r\n\r\n            if ( name.slice( -5 ) !== \"Until\" ) {\r\n                selector = until;\r\n            }\r\n\r\n            if ( selector && typeof selector === \"string\" ) {\r\n                matched = jQuery.filter( selector, matched );\r\n            }\r\n\r\n            if ( this.length > 1 ) {\r\n\r\n                // Remove duplicates\r\n                if ( !guaranteedUnique[ name ] ) {\r\n                    jQuery.uniqueSort( matched );\r\n                }\r\n\r\n                // Reverse order for parents* and prev-derivatives\r\n                if ( rparentsprev.test( name ) ) {\r\n                    matched.reverse();\r\n                }\r\n            }\r\n\r\n            return this.pushStack( matched );\r\n        };\r\n    } );\r\n    var rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\r\n\r\n\r\n\r\n// Convert String-formatted options into Object-formatted ones\r\n    function createOptions( options ) {\r\n        var object = {};\r\n        jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\r\n            object[ flag ] = true;\r\n        } );\r\n        return object;\r\n    }\r\n\r\n    /*\r\n * Create a callback list using the following parameters:\r\n *\r\n *\toptions: an optional list of space-separated options that will change how\r\n *\t\t\tthe callback list behaves or a more traditional option object\r\n *\r\n * By default a callback list will act like an event callback list and can be\r\n * \"fired\" multiple times.\r\n *\r\n * Possible options:\r\n *\r\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\r\n *\r\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\r\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\r\n *\t\t\t\t\tvalues (like a Deferred)\r\n *\r\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\r\n *\r\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\r\n *\r\n */\r\n    jQuery.Callbacks = function( options ) {\r\n\r\n        // Convert options from String-formatted to Object-formatted if needed\r\n        // (we check in cache first)\r\n        options = typeof options === \"string\" ?\r\n            createOptions( options ) :\r\n            jQuery.extend( {}, options );\r\n\r\n        var // Flag to know if list is currently firing\r\n            firing,\r\n\r\n            // Last fire value for non-forgettable lists\r\n            memory,\r\n\r\n            // Flag to know if list was already fired\r\n            fired,\r\n\r\n            // Flag to prevent firing\r\n            locked,\r\n\r\n            // Actual callback list\r\n            list = [],\r\n\r\n            // Queue of execution data for repeatable lists\r\n            queue = [],\r\n\r\n            // Index of currently firing callback (modified by add/remove as needed)\r\n            firingIndex = -1,\r\n\r\n            // Fire callbacks\r\n            fire = function() {\r\n\r\n                // Enforce single-firing\r\n                locked = locked || options.once;\r\n\r\n                // Execute callbacks for all pending executions,\r\n                // respecting firingIndex overrides and runtime changes\r\n                fired = firing = true;\r\n                for ( ; queue.length; firingIndex = -1 ) {\r\n                    memory = queue.shift();\r\n                    while ( ++firingIndex < list.length ) {\r\n\r\n                        // Run callback and check for early termination\r\n                        if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\r\n                            options.stopOnFalse ) {\r\n\r\n                            // Jump to end and forget the data so .add doesn't re-fire\r\n                            firingIndex = list.length;\r\n                            memory = false;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // Forget the data if we're done with it\r\n                if ( !options.memory ) {\r\n                    memory = false;\r\n                }\r\n\r\n                firing = false;\r\n\r\n                // Clean up if we're done firing for good\r\n                if ( locked ) {\r\n\r\n                    // Keep an empty list if we have data for future add calls\r\n                    if ( memory ) {\r\n                        list = [];\r\n\r\n                        // Otherwise, this object is spent\r\n                    } else {\r\n                        list = \"\";\r\n                    }\r\n                }\r\n            },\r\n\r\n            // Actual Callbacks object\r\n            self = {\r\n\r\n                // Add a callback or a collection of callbacks to the list\r\n                add: function() {\r\n                    if ( list ) {\r\n\r\n                        // If we have memory from a past run, we should fire after adding\r\n                        if ( memory && !firing ) {\r\n                            firingIndex = list.length - 1;\r\n                            queue.push( memory );\r\n                        }\r\n\r\n                        ( function add( args ) {\r\n                            jQuery.each( args, function( _, arg ) {\r\n                                if ( isFunction( arg ) ) {\r\n                                    if ( !options.unique || !self.has( arg ) ) {\r\n                                        list.push( arg );\r\n                                    }\r\n                                } else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\r\n\r\n                                    // Inspect recursively\r\n                                    add( arg );\r\n                                }\r\n                            } );\r\n                        } )( arguments );\r\n\r\n                        if ( memory && !firing ) {\r\n                            fire();\r\n                        }\r\n                    }\r\n                    return this;\r\n                },\r\n\r\n                // Remove a callback from the list\r\n                remove: function() {\r\n                    jQuery.each( arguments, function( _, arg ) {\r\n                        var index;\r\n                        while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\r\n                            list.splice( index, 1 );\r\n\r\n                            // Handle firing indexes\r\n                            if ( index <= firingIndex ) {\r\n                                firingIndex--;\r\n                            }\r\n                        }\r\n                    } );\r\n                    return this;\r\n                },\r\n\r\n                // Check if a given callback is in the list.\r\n                // If no argument is given, return whether or not list has callbacks attached.\r\n                has: function( fn ) {\r\n                    return fn ?\r\n                        jQuery.inArray( fn, list ) > -1 :\r\n                        list.length > 0;\r\n                },\r\n\r\n                // Remove all callbacks from the list\r\n                empty: function() {\r\n                    if ( list ) {\r\n                        list = [];\r\n                    }\r\n                    return this;\r\n                },\r\n\r\n                // Disable .fire and .add\r\n                // Abort any current/pending executions\r\n                // Clear all callbacks and values\r\n                disable: function() {\r\n                    locked = queue = [];\r\n                    list = memory = \"\";\r\n                    return this;\r\n                },\r\n                disabled: function() {\r\n                    return !list;\r\n                },\r\n\r\n                // Disable .fire\r\n                // Also disable .add unless we have memory (since it would have no effect)\r\n                // Abort any pending executions\r\n                lock: function() {\r\n                    locked = queue = [];\r\n                    if ( !memory && !firing ) {\r\n                        list = memory = \"\";\r\n                    }\r\n                    return this;\r\n                },\r\n                locked: function() {\r\n                    return !!locked;\r\n                },\r\n\r\n                // Call all callbacks with the given context and arguments\r\n                fireWith: function( context, args ) {\r\n                    if ( !locked ) {\r\n                        args = args || [];\r\n                        args = [ context, args.slice ? args.slice() : args ];\r\n                        queue.push( args );\r\n                        if ( !firing ) {\r\n                            fire();\r\n                        }\r\n                    }\r\n                    return this;\r\n                },\r\n\r\n                // Call all the callbacks with the given arguments\r\n                fire: function() {\r\n                    self.fireWith( this, arguments );\r\n                    return this;\r\n                },\r\n\r\n                // To know if the callbacks have already been called at least once\r\n                fired: function() {\r\n                    return !!fired;\r\n                }\r\n            };\r\n\r\n        return self;\r\n    };\r\n\r\n\r\n    function Identity( v ) {\r\n        return v;\r\n    }\r\n    function Thrower( ex ) {\r\n        throw ex;\r\n    }\r\n\r\n    function adoptValue( value, resolve, reject, noValue ) {\r\n        var method;\r\n\r\n        try {\r\n\r\n            // Check for promise aspect first to privilege synchronous behavior\r\n            if ( value && isFunction( ( method = value.promise ) ) ) {\r\n                method.call( value ).done( resolve ).fail( reject );\r\n\r\n                // Other thenables\r\n            } else if ( value && isFunction( ( method = value.then ) ) ) {\r\n                method.call( value, resolve, reject );\r\n\r\n                // Other non-thenables\r\n            } else {\r\n\r\n                // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\r\n                // * false: [ value ].slice( 0 ) => resolve( value )\r\n                // * true: [ value ].slice( 1 ) => resolve()\r\n                resolve.apply( undefined, [ value ].slice( noValue ) );\r\n            }\r\n\r\n            // For Promises/A+, convert exceptions into rejections\r\n            // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\r\n            // Deferred#then to conditionally suppress rejection.\r\n        } catch ( value ) {\r\n\r\n            // Support: Android 4.0 only\r\n            // Strict mode functions invoked without .call/.apply get global-object context\r\n            reject.apply( undefined, [ value ] );\r\n        }\r\n    }\r\n\r\n    jQuery.extend( {\r\n\r\n        Deferred: function( func ) {\r\n            var tuples = [\r\n\r\n                    // action, add listener, callbacks,\r\n                    // ... .then handlers, argument index, [final state]\r\n                    [ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\r\n                        jQuery.Callbacks( \"memory\" ), 2 ],\r\n                    [ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\r\n                        jQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\r\n                    [ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\r\n                        jQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\r\n                ],\r\n                state = \"pending\",\r\n                promise = {\r\n                    state: function() {\r\n                        return state;\r\n                    },\r\n                    always: function() {\r\n                        deferred.done( arguments ).fail( arguments );\r\n                        return this;\r\n                    },\r\n                    \"catch\": function( fn ) {\r\n                        return promise.then( null, fn );\r\n                    },\r\n\r\n                    // Keep pipe for back-compat\r\n                    pipe: function( /* fnDone, fnFail, fnProgress */ ) {\r\n                        var fns = arguments;\r\n\r\n                        return jQuery.Deferred( function( newDefer ) {\r\n                            jQuery.each( tuples, function( _i, tuple ) {\r\n\r\n                                // Map tuples (progress, done, fail) to arguments (done, fail, progress)\r\n                                var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\r\n\r\n                                // deferred.progress(function() { bind to newDefer or newDefer.notify })\r\n                                // deferred.done(function() { bind to newDefer or newDefer.resolve })\r\n                                // deferred.fail(function() { bind to newDefer or newDefer.reject })\r\n                                deferred[ tuple[ 1 ] ]( function() {\r\n                                    var returned = fn && fn.apply( this, arguments );\r\n                                    if ( returned && isFunction( returned.promise ) ) {\r\n                                        returned.promise()\r\n                                            .progress( newDefer.notify )\r\n                                            .done( newDefer.resolve )\r\n                                            .fail( newDefer.reject );\r\n                                    } else {\r\n                                        newDefer[ tuple[ 0 ] + \"With\" ](\r\n                                            this,\r\n                                            fn ? [ returned ] : arguments\r\n                                        );\r\n                                    }\r\n                                } );\r\n                            } );\r\n                            fns = null;\r\n                        } ).promise();\r\n                    },\r\n                    then: function( onFulfilled, onRejected, onProgress ) {\r\n                        var maxDepth = 0;\r\n                        function resolve( depth, deferred, handler, special ) {\r\n                            return function() {\r\n                                var that = this,\r\n                                    args = arguments,\r\n                                    mightThrow = function() {\r\n                                        var returned, then;\r\n\r\n                                        // Support: Promises/A+ section 2.3.3.3.3\r\n                                        // https://promisesaplus.com/#point-59\r\n                                        // Ignore double-resolution attempts\r\n                                        if ( depth < maxDepth ) {\r\n                                            return;\r\n                                        }\r\n\r\n                                        returned = handler.apply( that, args );\r\n\r\n                                        // Support: Promises/A+ section 2.3.1\r\n                                        // https://promisesaplus.com/#point-48\r\n                                        if ( returned === deferred.promise() ) {\r\n                                            throw new TypeError( \"Thenable self-resolution\" );\r\n                                        }\r\n\r\n                                        // Support: Promises/A+ sections 2.3.3.1, 3.5\r\n                                        // https://promisesaplus.com/#point-54\r\n                                        // https://promisesaplus.com/#point-75\r\n                                        // Retrieve `then` only once\r\n                                        then = returned &&\r\n\r\n                                            // Support: Promises/A+ section 2.3.4\r\n                                            // https://promisesaplus.com/#point-64\r\n                                            // Only check objects and functions for thenability\r\n                                            ( typeof returned === \"object\" ||\r\n                                                typeof returned === \"function\" ) &&\r\n                                            returned.then;\r\n\r\n                                        // Handle a returned thenable\r\n                                        if ( isFunction( then ) ) {\r\n\r\n                                            // Special processors (notify) just wait for resolution\r\n                                            if ( special ) {\r\n                                                then.call(\r\n                                                    returned,\r\n                                                    resolve( maxDepth, deferred, Identity, special ),\r\n                                                    resolve( maxDepth, deferred, Thrower, special )\r\n                                                );\r\n\r\n                                                // Normal processors (resolve) also hook into progress\r\n                                            } else {\r\n\r\n                                                // ...and disregard older resolution values\r\n                                                maxDepth++;\r\n\r\n                                                then.call(\r\n                                                    returned,\r\n                                                    resolve( maxDepth, deferred, Identity, special ),\r\n                                                    resolve( maxDepth, deferred, Thrower, special ),\r\n                                                    resolve( maxDepth, deferred, Identity,\r\n                                                        deferred.notifyWith )\r\n                                                );\r\n                                            }\r\n\r\n                                            // Handle all other returned values\r\n                                        } else {\r\n\r\n                                            // Only substitute handlers pass on context\r\n                                            // and multiple values (non-spec behavior)\r\n                                            if ( handler !== Identity ) {\r\n                                                that = undefined;\r\n                                                args = [ returned ];\r\n                                            }\r\n\r\n                                            // Process the value(s)\r\n                                            // Default process is resolve\r\n                                            ( special || deferred.resolveWith )( that, args );\r\n                                        }\r\n                                    },\r\n\r\n                                    // Only normal processors (resolve) catch and reject exceptions\r\n                                    process = special ?\r\n                                        mightThrow :\r\n                                        function() {\r\n                                            try {\r\n                                                mightThrow();\r\n                                            } catch ( e ) {\r\n\r\n                                                if ( jQuery.Deferred.exceptionHook ) {\r\n                                                    jQuery.Deferred.exceptionHook( e,\r\n                                                        process.stackTrace );\r\n                                                }\r\n\r\n                                                // Support: Promises/A+ section 2.3.3.3.4.1\r\n                                                // https://promisesaplus.com/#point-61\r\n                                                // Ignore post-resolution exceptions\r\n                                                if ( depth + 1 >= maxDepth ) {\r\n\r\n                                                    // Only substitute handlers pass on context\r\n                                                    // and multiple values (non-spec behavior)\r\n                                                    if ( handler !== Thrower ) {\r\n                                                        that = undefined;\r\n                                                        args = [ e ];\r\n                                                    }\r\n\r\n                                                    deferred.rejectWith( that, args );\r\n                                                }\r\n                                            }\r\n                                        };\r\n\r\n                                // Support: Promises/A+ section 2.3.3.3.1\r\n                                // https://promisesaplus.com/#point-57\r\n                                // Re-resolve promises immediately to dodge false rejection from\r\n                                // subsequent errors\r\n                                if ( depth ) {\r\n                                    process();\r\n                                } else {\r\n\r\n                                    // Call an optional hook to record the stack, in case of exception\r\n                                    // since it's otherwise lost when execution goes async\r\n                                    if ( jQuery.Deferred.getStackHook ) {\r\n                                        process.stackTrace = jQuery.Deferred.getStackHook();\r\n                                    }\r\n                                    window.setTimeout( process );\r\n                                }\r\n                            };\r\n                        }\r\n\r\n                        return jQuery.Deferred( function( newDefer ) {\r\n\r\n                            // progress_handlers.add( ... )\r\n                            tuples[ 0 ][ 3 ].add(\r\n                                resolve(\r\n                                    0,\r\n                                    newDefer,\r\n                                    isFunction( onProgress ) ?\r\n                                        onProgress :\r\n                                        Identity,\r\n                                    newDefer.notifyWith\r\n                                )\r\n                            );\r\n\r\n                            // fulfilled_handlers.add( ... )\r\n                            tuples[ 1 ][ 3 ].add(\r\n                                resolve(\r\n                                    0,\r\n                                    newDefer,\r\n                                    isFunction( onFulfilled ) ?\r\n                                        onFulfilled :\r\n                                        Identity\r\n                                )\r\n                            );\r\n\r\n                            // rejected_handlers.add( ... )\r\n                            tuples[ 2 ][ 3 ].add(\r\n                                resolve(\r\n                                    0,\r\n                                    newDefer,\r\n                                    isFunction( onRejected ) ?\r\n                                        onRejected :\r\n                                        Thrower\r\n                                )\r\n                            );\r\n                        } ).promise();\r\n                    },\r\n\r\n                    // Get a promise for this deferred\r\n                    // If obj is provided, the promise aspect is added to the object\r\n                    promise: function( obj ) {\r\n                        return obj != null ? jQuery.extend( obj, promise ) : promise;\r\n                    }\r\n                },\r\n                deferred = {};\r\n\r\n            // Add list-specific methods\r\n            jQuery.each( tuples, function( i, tuple ) {\r\n                var list = tuple[ 2 ],\r\n                    stateString = tuple[ 5 ];\r\n\r\n                // promise.progress = list.add\r\n                // promise.done = list.add\r\n                // promise.fail = list.add\r\n                promise[ tuple[ 1 ] ] = list.add;\r\n\r\n                // Handle state\r\n                if ( stateString ) {\r\n                    list.add(\r\n                        function() {\r\n\r\n                            // state = \"resolved\" (i.e., fulfilled)\r\n                            // state = \"rejected\"\r\n                            state = stateString;\r\n                        },\r\n\r\n                        // rejected_callbacks.disable\r\n                        // fulfilled_callbacks.disable\r\n                        tuples[ 3 - i ][ 2 ].disable,\r\n\r\n                        // rejected_handlers.disable\r\n                        // fulfilled_handlers.disable\r\n                        tuples[ 3 - i ][ 3 ].disable,\r\n\r\n                        // progress_callbacks.lock\r\n                        tuples[ 0 ][ 2 ].lock,\r\n\r\n                        // progress_handlers.lock\r\n                        tuples[ 0 ][ 3 ].lock\r\n                    );\r\n                }\r\n\r\n                // progress_handlers.fire\r\n                // fulfilled_handlers.fire\r\n                // rejected_handlers.fire\r\n                list.add( tuple[ 3 ].fire );\r\n\r\n                // deferred.notify = function() { deferred.notifyWith(...) }\r\n                // deferred.resolve = function() { deferred.resolveWith(...) }\r\n                // deferred.reject = function() { deferred.rejectWith(...) }\r\n                deferred[ tuple[ 0 ] ] = function() {\r\n                    deferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\r\n                    return this;\r\n                };\r\n\r\n                // deferred.notifyWith = list.fireWith\r\n                // deferred.resolveWith = list.fireWith\r\n                // deferred.rejectWith = list.fireWith\r\n                deferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\r\n            } );\r\n\r\n            // Make the deferred a promise\r\n            promise.promise( deferred );\r\n\r\n            // Call given func if any\r\n            if ( func ) {\r\n                func.call( deferred, deferred );\r\n            }\r\n\r\n            // All done!\r\n            return deferred;\r\n        },\r\n\r\n        // Deferred helper\r\n        when: function( singleValue ) {\r\n            var\r\n\r\n                // count of uncompleted subordinates\r\n                remaining = arguments.length,\r\n\r\n                // count of unprocessed arguments\r\n                i = remaining,\r\n\r\n                // subordinate fulfillment data\r\n                resolveContexts = Array( i ),\r\n                resolveValues = slice.call( arguments ),\r\n\r\n                // the primary Deferred\r\n                primary = jQuery.Deferred(),\r\n\r\n                // subordinate callback factory\r\n                updateFunc = function( i ) {\r\n                    return function( value ) {\r\n                        resolveContexts[ i ] = this;\r\n                        resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\r\n                        if ( !( --remaining ) ) {\r\n                            primary.resolveWith( resolveContexts, resolveValues );\r\n                        }\r\n                    };\r\n                };\r\n\r\n            // Single- and empty arguments are adopted like Promise.resolve\r\n            if ( remaining <= 1 ) {\r\n                adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,\r\n                    !remaining );\r\n\r\n                // Use .then() to unwrap secondary thenables (cf. gh-3000)\r\n                if ( primary.state() === \"pending\" ||\r\n                    isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\r\n\r\n                    return primary.then();\r\n                }\r\n            }\r\n\r\n            // Multiple arguments are aggregated like Promise.all array elements\r\n            while ( i-- ) {\r\n                adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );\r\n            }\r\n\r\n            return primary.promise();\r\n        }\r\n    } );\r\n\r\n\r\n// These usually indicate a programmer mistake during development,\r\n// warn about them ASAP rather than swallowing them by default.\r\n    var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\r\n\r\n    jQuery.Deferred.exceptionHook = function( error, stack ) {\r\n\r\n        // Support: IE 8 - 9 only\r\n        // Console exists when dev tools are open, which can happen at any time\r\n        if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\r\n            window.console.warn( \"jQuery.Deferred exception: \" + error.message, error.stack, stack );\r\n        }\r\n    };\r\n\r\n\r\n\r\n\r\n    jQuery.readyException = function( error ) {\r\n        window.setTimeout( function() {\r\n            throw error;\r\n        } );\r\n    };\r\n\r\n\r\n\r\n\r\n// The deferred used on DOM ready\r\n    var readyList = jQuery.Deferred();\r\n\r\n    jQuery.fn.ready = function( fn ) {\r\n\r\n        readyList\r\n            .then( fn )\r\n\r\n            // Wrap jQuery.readyException in a function so that the lookup\r\n            // happens at the time of error handling instead of callback\r\n            // registration.\r\n            .catch( function( error ) {\r\n                jQuery.readyException( error );\r\n            } );\r\n\r\n        return this;\r\n    };\r\n\r\n    jQuery.extend( {\r\n\r\n        // Is the DOM ready to be used? Set to true once it occurs.\r\n        isReady: false,\r\n\r\n        // A counter to track how many items to wait for before\r\n        // the ready event fires. See #6781\r\n        readyWait: 1,\r\n\r\n        // Handle when the DOM is ready\r\n        ready: function( wait ) {\r\n\r\n            // Abort if there are pending holds or we're already ready\r\n            if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\r\n                return;\r\n            }\r\n\r\n            // Remember that the DOM is ready\r\n            jQuery.isReady = true;\r\n\r\n            // If a normal DOM Ready event fired, decrement, and wait if need be\r\n            if ( wait !== true && --jQuery.readyWait > 0 ) {\r\n                return;\r\n            }\r\n\r\n            // If there are functions bound, to execute\r\n            readyList.resolveWith( document, [ jQuery ] );\r\n        }\r\n    } );\r\n\r\n    jQuery.ready.then = readyList.then;\r\n\r\n// The ready event handler and self cleanup method\r\n    function completed() {\r\n        document.removeEventListener( \"DOMContentLoaded\", completed );\r\n        window.removeEventListener( \"load\", completed );\r\n        jQuery.ready();\r\n    }\r\n\r\n// Catch cases where $(document).ready() is called\r\n// after the browser event has already occurred.\r\n// Support: IE <=9 - 10 only\r\n// Older IE sometimes signals \"interactive\" too soon\r\n    if ( document.readyState === \"complete\" ||\r\n        ( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\r\n\r\n        // Handle it asynchronously to allow scripts the opportunity to delay ready\r\n        window.setTimeout( jQuery.ready );\r\n\r\n    } else {\r\n\r\n        // Use the handy event callback\r\n        document.addEventListener( \"DOMContentLoaded\", completed );\r\n\r\n        // A fallback to window.onload, that will always work\r\n        window.addEventListener( \"load\", completed );\r\n    }\r\n\r\n\r\n\r\n\r\n// Multifunctional method to get and set values of a collection\r\n// The value/s can optionally be executed if it's a function\r\n    var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\r\n        var i = 0,\r\n            len = elems.length,\r\n            bulk = key == null;\r\n\r\n        // Sets many values\r\n        if ( toType( key ) === \"object\" ) {\r\n            chainable = true;\r\n            for ( i in key ) {\r\n                access( elems, fn, i, key[ i ], true, emptyGet, raw );\r\n            }\r\n\r\n            // Sets one value\r\n        } else if ( value !== undefined ) {\r\n            chainable = true;\r\n\r\n            if ( !isFunction( value ) ) {\r\n                raw = true;\r\n            }\r\n\r\n            if ( bulk ) {\r\n\r\n                // Bulk operations run against the entire set\r\n                if ( raw ) {\r\n                    fn.call( elems, value );\r\n                    fn = null;\r\n\r\n                    // ...except when executing function values\r\n                } else {\r\n                    bulk = fn;\r\n                    fn = function( elem, _key, value ) {\r\n                        return bulk.call( jQuery( elem ), value );\r\n                    };\r\n                }\r\n            }\r\n\r\n            if ( fn ) {\r\n                for ( ; i < len; i++ ) {\r\n                    fn(\r\n                        elems[ i ], key, raw ?\r\n                            value :\r\n                            value.call( elems[ i ], i, fn( elems[ i ], key ) )\r\n                    );\r\n                }\r\n            }\r\n        }\r\n\r\n        if ( chainable ) {\r\n            return elems;\r\n        }\r\n\r\n        // Gets\r\n        if ( bulk ) {\r\n            return fn.call( elems );\r\n        }\r\n\r\n        return len ? fn( elems[ 0 ], key ) : emptyGet;\r\n    };\r\n\r\n\r\n// Matches dashed string for camelizing\r\n    var rmsPrefix = /^-ms-/,\r\n        rdashAlpha = /-([a-z])/g;\r\n\r\n// Used by camelCase as callback to replace()\r\n    function fcamelCase( _all, letter ) {\r\n        return letter.toUpperCase();\r\n    }\r\n\r\n// Convert dashed to camelCase; used by the css and data modules\r\n// Support: IE <=9 - 11, Edge 12 - 15\r\n// Microsoft forgot to hump their vendor prefix (#9572)\r\n    function camelCase( string ) {\r\n        return string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\r\n    }\r\n    var acceptData = function( owner ) {\r\n\r\n        // Accepts only:\r\n        //  - Node\r\n        //    - Node.ELEMENT_NODE\r\n        //    - Node.DOCUMENT_NODE\r\n        //  - Object\r\n        //    - Any\r\n        return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\r\n    };\r\n\r\n\r\n\r\n\r\n    function Data() {\r\n        this.expando = jQuery.expando + Data.uid++;\r\n    }\r\n\r\n    Data.uid = 1;\r\n\r\n    Data.prototype = {\r\n\r\n        cache: function( owner ) {\r\n\r\n            // Check if the owner object already has a cache\r\n            var value = owner[ this.expando ];\r\n\r\n            // If not, create one\r\n            if ( !value ) {\r\n                value = {};\r\n\r\n                // We can accept data for non-element nodes in modern browsers,\r\n                // but we should not, see #8335.\r\n                // Always return an empty object.\r\n                if ( acceptData( owner ) ) {\r\n\r\n                    // If it is a node unlikely to be stringify-ed or looped over\r\n                    // use plain assignment\r\n                    if ( owner.nodeType ) {\r\n                        owner[ this.expando ] = value;\r\n\r\n                        // Otherwise secure it in a non-enumerable property\r\n                        // configurable must be true to allow the property to be\r\n                        // deleted when data is removed\r\n                    } else {\r\n                        Object.defineProperty( owner, this.expando, {\r\n                            value: value,\r\n                            configurable: true\r\n                        } );\r\n                    }\r\n                }\r\n            }\r\n\r\n            return value;\r\n        },\r\n        set: function( owner, data, value ) {\r\n            var prop,\r\n                cache = this.cache( owner );\r\n\r\n            // Handle: [ owner, key, value ] args\r\n            // Always use camelCase key (gh-2257)\r\n            if ( typeof data === \"string\" ) {\r\n                cache[ camelCase( data ) ] = value;\r\n\r\n                // Handle: [ owner, { properties } ] args\r\n            } else {\r\n\r\n                // Copy the properties one-by-one to the cache object\r\n                for ( prop in data ) {\r\n                    cache[ camelCase( prop ) ] = data[ prop ];\r\n                }\r\n            }\r\n            return cache;\r\n        },\r\n        get: function( owner, key ) {\r\n            return key === undefined ?\r\n                this.cache( owner ) :\r\n\r\n                // Always use camelCase key (gh-2257)\r\n                owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\r\n        },\r\n        access: function( owner, key, value ) {\r\n\r\n            // In cases where either:\r\n            //\r\n            //   1. No key was specified\r\n            //   2. A string key was specified, but no value provided\r\n            //\r\n            // Take the \"read\" path and allow the get method to determine\r\n            // which value to return, respectively either:\r\n            //\r\n            //   1. The entire cache object\r\n            //   2. The data stored at the key\r\n            //\r\n            if ( key === undefined ||\r\n                ( ( key && typeof key === \"string\" ) && value === undefined ) ) {\r\n\r\n                return this.get( owner, key );\r\n            }\r\n\r\n            // When the key is not a string, or both a key and value\r\n            // are specified, set or extend (existing objects) with either:\r\n            //\r\n            //   1. An object of properties\r\n            //   2. A key and value\r\n            //\r\n            this.set( owner, key, value );\r\n\r\n            // Since the \"set\" path can have two possible entry points\r\n            // return the expected data based on which path was taken[*]\r\n            return value !== undefined ? value : key;\r\n        },\r\n        remove: function( owner, key ) {\r\n            var i,\r\n                cache = owner[ this.expando ];\r\n\r\n            if ( cache === undefined ) {\r\n                return;\r\n            }\r\n\r\n            if ( key !== undefined ) {\r\n\r\n                // Support array or space separated string of keys\r\n                if ( Array.isArray( key ) ) {\r\n\r\n                    // If key is an array of keys...\r\n                    // We always set camelCase keys, so remove that.\r\n                    key = key.map( camelCase );\r\n                } else {\r\n                    key = camelCase( key );\r\n\r\n                    // If a key with the spaces exists, use it.\r\n                    // Otherwise, create an array by matching non-whitespace\r\n                    key = key in cache ?\r\n                        [ key ] :\r\n                        ( key.match( rnothtmlwhite ) || [] );\r\n                }\r\n\r\n                i = key.length;\r\n\r\n                while ( i-- ) {\r\n                    delete cache[ key[ i ] ];\r\n                }\r\n            }\r\n\r\n            // Remove the expando if there's no more data\r\n            if ( key === undefined || jQuery.isEmptyObject( cache ) ) {\r\n\r\n                // Support: Chrome <=35 - 45\r\n                // Webkit & Blink performance suffers when deleting properties\r\n                // from DOM nodes, so set to undefined instead\r\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\r\n                if ( owner.nodeType ) {\r\n                    owner[ this.expando ] = undefined;\r\n                } else {\r\n                    delete owner[ this.expando ];\r\n                }\r\n            }\r\n        },\r\n        hasData: function( owner ) {\r\n            var cache = owner[ this.expando ];\r\n            return cache !== undefined && !jQuery.isEmptyObject( cache );\r\n        }\r\n    };\r\n    var dataPriv = new Data();\r\n\r\n    var dataUser = new Data();\r\n\r\n\r\n\r\n//\tImplementation Summary\r\n//\r\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\r\n//\t2. Improve the module's maintainability by reducing the storage\r\n//\t\tpaths to a single mechanism.\r\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\r\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\r\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\r\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\r\n\r\n    var rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\r\n        rmultiDash = /[A-Z]/g;\r\n\r\n    function getData( data ) {\r\n        if ( data === \"true\" ) {\r\n            return true;\r\n        }\r\n\r\n        if ( data === \"false\" ) {\r\n            return false;\r\n        }\r\n\r\n        if ( data === \"null\" ) {\r\n            return null;\r\n        }\r\n\r\n        // Only convert to a number if it doesn't change the string\r\n        if ( data === +data + \"\" ) {\r\n            return +data;\r\n        }\r\n\r\n        if ( rbrace.test( data ) ) {\r\n            return JSON.parse( data );\r\n        }\r\n\r\n        return data;\r\n    }\r\n\r\n    function dataAttr( elem, key, data ) {\r\n        var name;\r\n\r\n        // If nothing was found internally, try to fetch any\r\n        // data from the HTML5 data-* attribute\r\n        if ( data === undefined && elem.nodeType === 1 ) {\r\n            name = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\r\n            data = elem.getAttribute( name );\r\n\r\n            if ( typeof data === \"string\" ) {\r\n                try {\r\n                    data = getData( data );\r\n                } catch ( e ) {}\r\n\r\n                // Make sure we set the data so it isn't changed later\r\n                dataUser.set( elem, key, data );\r\n            } else {\r\n                data = undefined;\r\n            }\r\n        }\r\n        return data;\r\n    }\r\n\r\n    jQuery.extend( {\r\n        hasData: function( elem ) {\r\n            return dataUser.hasData( elem ) || dataPriv.hasData( elem );\r\n        },\r\n\r\n        data: function( elem, name, data ) {\r\n            return dataUser.access( elem, name, data );\r\n        },\r\n\r\n        removeData: function( elem, name ) {\r\n            dataUser.remove( elem, name );\r\n        },\r\n\r\n        // TODO: Now that all calls to _data and _removeData have been replaced\r\n        // with direct calls to dataPriv methods, these can be deprecated.\r\n        _data: function( elem, name, data ) {\r\n            return dataPriv.access( elem, name, data );\r\n        },\r\n\r\n        _removeData: function( elem, name ) {\r\n            dataPriv.remove( elem, name );\r\n        }\r\n    } );\r\n\r\n    jQuery.fn.extend( {\r\n        data: function( key, value ) {\r\n            var i, name, data,\r\n                elem = this[ 0 ],\r\n                attrs = elem && elem.attributes;\r\n\r\n            // Gets all values\r\n            if ( key === undefined ) {\r\n                if ( this.length ) {\r\n                    data = dataUser.get( elem );\r\n\r\n                    if ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\r\n                        i = attrs.length;\r\n                        while ( i-- ) {\r\n\r\n                            // Support: IE 11 only\r\n                            // The attrs elements can be null (#14894)\r\n                            if ( attrs[ i ] ) {\r\n                                name = attrs[ i ].name;\r\n                                if ( name.indexOf( \"data-\" ) === 0 ) {\r\n                                    name = camelCase( name.slice( 5 ) );\r\n                                    dataAttr( elem, name, data[ name ] );\r\n                                }\r\n                            }\r\n                        }\r\n                        dataPriv.set( elem, \"hasDataAttrs\", true );\r\n                    }\r\n                }\r\n\r\n                return data;\r\n            }\r\n\r\n            // Sets multiple values\r\n            if ( typeof key === \"object\" ) {\r\n                return this.each( function() {\r\n                    dataUser.set( this, key );\r\n                } );\r\n            }\r\n\r\n            return access( this, function( value ) {\r\n                var data;\r\n\r\n                // The calling jQuery object (element matches) is not empty\r\n                // (and therefore has an element appears at this[ 0 ]) and the\r\n                // `value` parameter was not undefined. An empty jQuery object\r\n                // will result in `undefined` for elem = this[ 0 ] which will\r\n                // throw an exception if an attempt to read a data cache is made.\r\n                if ( elem && value === undefined ) {\r\n\r\n                    // Attempt to get data from the cache\r\n                    // The key will always be camelCased in Data\r\n                    data = dataUser.get( elem, key );\r\n                    if ( data !== undefined ) {\r\n                        return data;\r\n                    }\r\n\r\n                    // Attempt to \"discover\" the data in\r\n                    // HTML5 custom data-* attrs\r\n                    data = dataAttr( elem, key );\r\n                    if ( data !== undefined ) {\r\n                        return data;\r\n                    }\r\n\r\n                    // We tried really hard, but the data doesn't exist.\r\n                    return;\r\n                }\r\n\r\n                // Set the data...\r\n                this.each( function() {\r\n\r\n                    // We always store the camelCased key\r\n                    dataUser.set( this, key, value );\r\n                } );\r\n            }, null, value, arguments.length > 1, null, true );\r\n        },\r\n\r\n        removeData: function( key ) {\r\n            return this.each( function() {\r\n                dataUser.remove( this, key );\r\n            } );\r\n        }\r\n    } );\r\n\r\n\r\n    jQuery.extend( {\r\n        queue: function( elem, type, data ) {\r\n            var queue;\r\n\r\n            if ( elem ) {\r\n                type = ( type || \"fx\" ) + \"queue\";\r\n                queue = dataPriv.get( elem, type );\r\n\r\n                // Speed up dequeue by getting out quickly if this is just a lookup\r\n                if ( data ) {\r\n                    if ( !queue || Array.isArray( data ) ) {\r\n                        queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\r\n                    } else {\r\n                        queue.push( data );\r\n                    }\r\n                }\r\n                return queue || [];\r\n            }\r\n        },\r\n\r\n        dequeue: function( elem, type ) {\r\n            type = type || \"fx\";\r\n\r\n            var queue = jQuery.queue( elem, type ),\r\n                startLength = queue.length,\r\n                fn = queue.shift(),\r\n                hooks = jQuery._queueHooks( elem, type ),\r\n                next = function() {\r\n                    jQuery.dequeue( elem, type );\r\n                };\r\n\r\n            // If the fx queue is dequeued, always remove the progress sentinel\r\n            if ( fn === \"inprogress\" ) {\r\n                fn = queue.shift();\r\n                startLength--;\r\n            }\r\n\r\n            if ( fn ) {\r\n\r\n                // Add a progress sentinel to prevent the fx queue from being\r\n                // automatically dequeued\r\n                if ( type === \"fx\" ) {\r\n                    queue.unshift( \"inprogress\" );\r\n                }\r\n\r\n                // Clear up the last queue stop function\r\n                delete hooks.stop;\r\n                fn.call( elem, next, hooks );\r\n            }\r\n\r\n            if ( !startLength && hooks ) {\r\n                hooks.empty.fire();\r\n            }\r\n        },\r\n\r\n        // Not public - generate a queueHooks object, or return the current one\r\n        _queueHooks: function( elem, type ) {\r\n            var key = type + \"queueHooks\";\r\n            return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\r\n                empty: jQuery.Callbacks( \"once memory\" ).add( function() {\r\n                    dataPriv.remove( elem, [ type + \"queue\", key ] );\r\n                } )\r\n            } );\r\n        }\r\n    } );\r\n\r\n    jQuery.fn.extend( {\r\n        queue: function( type, data ) {\r\n            var setter = 2;\r\n\r\n            if ( typeof type !== \"string\" ) {\r\n                data = type;\r\n                type = \"fx\";\r\n                setter--;\r\n            }\r\n\r\n            if ( arguments.length < setter ) {\r\n                return jQuery.queue( this[ 0 ], type );\r\n            }\r\n\r\n            return data === undefined ?\r\n                this :\r\n                this.each( function() {\r\n                    var queue = jQuery.queue( this, type, data );\r\n\r\n                    // Ensure a hooks for this queue\r\n                    jQuery._queueHooks( this, type );\r\n\r\n                    if ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\r\n                        jQuery.dequeue( this, type );\r\n                    }\r\n                } );\r\n        },\r\n        dequeue: function( type ) {\r\n            return this.each( function() {\r\n                jQuery.dequeue( this, type );\r\n            } );\r\n        },\r\n        clearQueue: function( type ) {\r\n            return this.queue( type || \"fx\", [] );\r\n        },\r\n\r\n        // Get a promise resolved when queues of a certain type\r\n        // are emptied (fx is the type by default)\r\n        promise: function( type, obj ) {\r\n            var tmp,\r\n                count = 1,\r\n                defer = jQuery.Deferred(),\r\n                elements = this,\r\n                i = this.length,\r\n                resolve = function() {\r\n                    if ( !( --count ) ) {\r\n                        defer.resolveWith( elements, [ elements ] );\r\n                    }\r\n                };\r\n\r\n            if ( typeof type !== \"string\" ) {\r\n                obj = type;\r\n                type = undefined;\r\n            }\r\n            type = type || \"fx\";\r\n\r\n            while ( i-- ) {\r\n                tmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\r\n                if ( tmp && tmp.empty ) {\r\n                    count++;\r\n                    tmp.empty.add( resolve );\r\n                }\r\n            }\r\n            resolve();\r\n            return defer.promise( obj );\r\n        }\r\n    } );\r\n    var pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\r\n\r\n    var rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\r\n\r\n\r\n    var cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\r\n\r\n    var documentElement = document.documentElement;\r\n\r\n\r\n\r\n    var isAttached = function( elem ) {\r\n            return jQuery.contains( elem.ownerDocument, elem );\r\n        },\r\n        composed = { composed: true };\r\n\r\n    // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\r\n    // Check attachment across shadow DOM boundaries when possible (gh-3504)\r\n    // Support: iOS 10.0-10.2 only\r\n    // Early iOS 10 versions support `attachShadow` but not `getRootNode`,\r\n    // leading to errors. We need to check for `getRootNode`.\r\n    if ( documentElement.getRootNode ) {\r\n        isAttached = function( elem ) {\r\n            return jQuery.contains( elem.ownerDocument, elem ) ||\r\n                elem.getRootNode( composed ) === elem.ownerDocument;\r\n        };\r\n    }\r\n    var isHiddenWithinTree = function( elem, el ) {\r\n\r\n        // isHiddenWithinTree might be called from jQuery#filter function;\r\n        // in that case, element will be second argument\r\n        elem = el || elem;\r\n\r\n        // Inline style trumps all\r\n        return elem.style.display === \"none\" ||\r\n            elem.style.display === \"\" &&\r\n\r\n            // Otherwise, check computed style\r\n            // Support: Firefox <=43 - 45\r\n            // Disconnected elements can have computed display: none, so first confirm that elem is\r\n            // in the document.\r\n            isAttached( elem ) &&\r\n\r\n            jQuery.css( elem, \"display\" ) === \"none\";\r\n    };\r\n\r\n\r\n\r\n    function adjustCSS( elem, prop, valueParts, tween ) {\r\n        var adjusted, scale,\r\n            maxIterations = 20,\r\n            currentValue = tween ?\r\n                function() {\r\n                    return tween.cur();\r\n                } :\r\n                function() {\r\n                    return jQuery.css( elem, prop, \"\" );\r\n                },\r\n            initial = currentValue(),\r\n            unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\r\n\r\n            // Starting value computation is required for potential unit mismatches\r\n            initialInUnit = elem.nodeType &&\r\n                ( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\r\n                rcssNum.exec( jQuery.css( elem, prop ) );\r\n\r\n        if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\r\n\r\n            // Support: Firefox <=54\r\n            // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\r\n            initial = initial / 2;\r\n\r\n            // Trust units reported by jQuery.css\r\n            unit = unit || initialInUnit[ 3 ];\r\n\r\n            // Iteratively approximate from a nonzero starting point\r\n            initialInUnit = +initial || 1;\r\n\r\n            while ( maxIterations-- ) {\r\n\r\n                // Evaluate and update our best guess (doubling guesses that zero out).\r\n                // Finish if the scale equals or crosses 1 (making the old*new product non-positive).\r\n                jQuery.style( elem, prop, initialInUnit + unit );\r\n                if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\r\n                    maxIterations = 0;\r\n                }\r\n                initialInUnit = initialInUnit / scale;\r\n\r\n            }\r\n\r\n            initialInUnit = initialInUnit * 2;\r\n            jQuery.style( elem, prop, initialInUnit + unit );\r\n\r\n            // Make sure we update the tween properties later on\r\n            valueParts = valueParts || [];\r\n        }\r\n\r\n        if ( valueParts ) {\r\n            initialInUnit = +initialInUnit || +initial || 0;\r\n\r\n            // Apply relative offset (+=/-=) if specified\r\n            adjusted = valueParts[ 1 ] ?\r\n                initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\r\n                +valueParts[ 2 ];\r\n            if ( tween ) {\r\n                tween.unit = unit;\r\n                tween.start = initialInUnit;\r\n                tween.end = adjusted;\r\n            }\r\n        }\r\n        return adjusted;\r\n    }\r\n\r\n\r\n    var defaultDisplayMap = {};\r\n\r\n    function getDefaultDisplay( elem ) {\r\n        var temp,\r\n            doc = elem.ownerDocument,\r\n            nodeName = elem.nodeName,\r\n            display = defaultDisplayMap[ nodeName ];\r\n\r\n        if ( display ) {\r\n            return display;\r\n        }\r\n\r\n        temp = doc.body.appendChild( doc.createElement( nodeName ) );\r\n        display = jQuery.css( temp, \"display\" );\r\n\r\n        temp.parentNode.removeChild( temp );\r\n\r\n        if ( display === \"none\" ) {\r\n            display = \"block\";\r\n        }\r\n        defaultDisplayMap[ nodeName ] = display;\r\n\r\n        return display;\r\n    }\r\n\r\n    function showHide( elements, show ) {\r\n        var display, elem,\r\n            values = [],\r\n            index = 0,\r\n            length = elements.length;\r\n\r\n        // Determine new display value for elements that need to change\r\n        for ( ; index < length; index++ ) {\r\n            elem = elements[ index ];\r\n            if ( !elem.style ) {\r\n                continue;\r\n            }\r\n\r\n            display = elem.style.display;\r\n            if ( show ) {\r\n\r\n                // Since we force visibility upon cascade-hidden elements, an immediate (and slow)\r\n                // check is required in this first loop unless we have a nonempty display value (either\r\n                // inline or about-to-be-restored)\r\n                if ( display === \"none\" ) {\r\n                    values[ index ] = dataPriv.get( elem, \"display\" ) || null;\r\n                    if ( !values[ index ] ) {\r\n                        elem.style.display = \"\";\r\n                    }\r\n                }\r\n                if ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\r\n                    values[ index ] = getDefaultDisplay( elem );\r\n                }\r\n            } else {\r\n                if ( display !== \"none\" ) {\r\n                    values[ index ] = \"none\";\r\n\r\n                    // Remember what we're overwriting\r\n                    dataPriv.set( elem, \"display\", display );\r\n                }\r\n            }\r\n        }\r\n\r\n        // Set the display of the elements in a second loop to avoid constant reflow\r\n        for ( index = 0; index < length; index++ ) {\r\n            if ( values[ index ] != null ) {\r\n                elements[ index ].style.display = values[ index ];\r\n            }\r\n        }\r\n\r\n        return elements;\r\n    }\r\n\r\n    jQuery.fn.extend( {\r\n        show: function() {\r\n            return showHide( this, true );\r\n        },\r\n        hide: function() {\r\n            return showHide( this );\r\n        },\r\n        toggle: function( state ) {\r\n            if ( typeof state === \"boolean\" ) {\r\n                return state ? this.show() : this.hide();\r\n            }\r\n\r\n            return this.each( function() {\r\n                if ( isHiddenWithinTree( this ) ) {\r\n                    jQuery( this ).show();\r\n                } else {\r\n                    jQuery( this ).hide();\r\n                }\r\n            } );\r\n        }\r\n    } );\r\n    var rcheckableType = ( /^(?:checkbox|radio)$/i );\r\n\r\n    var rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i );\r\n\r\n    var rscriptType = ( /^$|^module$|\\/(?:java|ecma)script/i );\r\n\r\n\r\n\r\n    ( function() {\r\n        var fragment = document.createDocumentFragment(),\r\n            div = fragment.appendChild( document.createElement( \"div\" ) ),\r\n            input = document.createElement( \"input\" );\r\n\r\n        // Support: Android 4.0 - 4.3 only\r\n        // Check state lost if the name is set (#11217)\r\n        // Support: Windows Web Apps (WWA)\r\n        // `name` and `type` must use .setAttribute for WWA (#14901)\r\n        input.setAttribute( \"type\", \"radio\" );\r\n        input.setAttribute( \"checked\", \"checked\" );\r\n        input.setAttribute( \"name\", \"t\" );\r\n\r\n        div.appendChild( input );\r\n\r\n        // Support: Android <=4.1 only\r\n        // Older WebKit doesn't clone checked state correctly in fragments\r\n        support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\r\n\r\n        // Support: IE <=11 only\r\n        // Make sure textarea (and checkbox) defaultValue is properly cloned\r\n        div.innerHTML = \"<textarea>x</textarea>\";\r\n        support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\r\n\r\n        // Support: IE <=9 only\r\n        // IE <=9 replaces <option> tags with their contents when inserted outside of\r\n        // the select element.\r\n        div.innerHTML = \"<option></option>\";\r\n        support.option = !!div.lastChild;\r\n    } )();\r\n\r\n\r\n// We have to close these tags to support XHTML (#13200)\r\n    var wrapMap = {\r\n\r\n        // XHTML parsers do not magically insert elements in the\r\n        // same way that tag soup parsers do. So we cannot shorten\r\n        // this by omitting <tbody> or other required elements.\r\n        thead: [ 1, \"<table>\", \"</table>\" ],\r\n        col: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\r\n        tr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\r\n        td: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\r\n\r\n        _default: [ 0, \"\", \"\" ]\r\n    };\r\n\r\n    wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\r\n    wrapMap.th = wrapMap.td;\r\n\r\n// Support: IE <=9 only\r\n    if ( !support.option ) {\r\n        wrapMap.optgroup = wrapMap.option = [ 1, \"<select multiple='multiple'>\", \"</select>\" ];\r\n    }\r\n\r\n\r\n    function getAll( context, tag ) {\r\n\r\n        // Support: IE <=9 - 11 only\r\n        // Use typeof to avoid zero-argument method invocation on host objects (#15151)\r\n        var ret;\r\n\r\n        if ( typeof context.getElementsByTagName !== \"undefined\" ) {\r\n            ret = context.getElementsByTagName( tag || \"*\" );\r\n\r\n        } else if ( typeof context.querySelectorAll !== \"undefined\" ) {\r\n            ret = context.querySelectorAll( tag || \"*\" );\r\n\r\n        } else {\r\n            ret = [];\r\n        }\r\n\r\n        if ( tag === undefined || tag && nodeName( context, tag ) ) {\r\n            return jQuery.merge( [ context ], ret );\r\n        }\r\n\r\n        return ret;\r\n    }\r\n\r\n\r\n// Mark scripts as having already been evaluated\r\n    function setGlobalEval( elems, refElements ) {\r\n        var i = 0,\r\n            l = elems.length;\r\n\r\n        for ( ; i < l; i++ ) {\r\n            dataPriv.set(\r\n                elems[ i ],\r\n                \"globalEval\",\r\n                !refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\r\n            );\r\n        }\r\n    }\r\n\r\n\r\n    var rhtml = /<|&#?\\w+;/;\r\n\r\n    function buildFragment( elems, context, scripts, selection, ignored ) {\r\n        var elem, tmp, tag, wrap, attached, j,\r\n            fragment = context.createDocumentFragment(),\r\n            nodes = [],\r\n            i = 0,\r\n            l = elems.length;\r\n\r\n        for ( ; i < l; i++ ) {\r\n            elem = elems[ i ];\r\n\r\n            if ( elem || elem === 0 ) {\r\n\r\n                // Add nodes directly\r\n                if ( toType( elem ) === \"object\" ) {\r\n\r\n                    // Support: Android <=4.0 only, PhantomJS 1 only\r\n                    // push.apply(_, arraylike) throws on ancient WebKit\r\n                    jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\r\n\r\n                    // Convert non-html into a text node\r\n                } else if ( !rhtml.test( elem ) ) {\r\n                    nodes.push( context.createTextNode( elem ) );\r\n\r\n                    // Convert html into DOM nodes\r\n                } else {\r\n                    tmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\r\n\r\n                    // Deserialize a standard representation\r\n                    tag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\r\n                    wrap = wrapMap[ tag ] || wrapMap._default;\r\n                    tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\r\n\r\n                    // Descend through wrappers to the right content\r\n                    j = wrap[ 0 ];\r\n                    while ( j-- ) {\r\n                        tmp = tmp.lastChild;\r\n                    }\r\n\r\n                    // Support: Android <=4.0 only, PhantomJS 1 only\r\n                    // push.apply(_, arraylike) throws on ancient WebKit\r\n                    jQuery.merge( nodes, tmp.childNodes );\r\n\r\n                    // Remember the top-level container\r\n                    tmp = fragment.firstChild;\r\n\r\n                    // Ensure the created nodes are orphaned (#12392)\r\n                    tmp.textContent = \"\";\r\n                }\r\n            }\r\n        }\r\n\r\n        // Remove wrapper from fragment\r\n        fragment.textContent = \"\";\r\n\r\n        i = 0;\r\n        while ( ( elem = nodes[ i++ ] ) ) {\r\n\r\n            // Skip elements already in the context collection (trac-4087)\r\n            if ( selection && jQuery.inArray( elem, selection ) > -1 ) {\r\n                if ( ignored ) {\r\n                    ignored.push( elem );\r\n                }\r\n                continue;\r\n            }\r\n\r\n            attached = isAttached( elem );\r\n\r\n            // Append to fragment\r\n            tmp = getAll( fragment.appendChild( elem ), \"script\" );\r\n\r\n            // Preserve script evaluation history\r\n            if ( attached ) {\r\n                setGlobalEval( tmp );\r\n            }\r\n\r\n            // Capture executables\r\n            if ( scripts ) {\r\n                j = 0;\r\n                while ( ( elem = tmp[ j++ ] ) ) {\r\n                    if ( rscriptType.test( elem.type || \"\" ) ) {\r\n                        scripts.push( elem );\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return fragment;\r\n    }\r\n\r\n\r\n    var rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\r\n\r\n    function returnTrue() {\r\n        return true;\r\n    }\r\n\r\n    function returnFalse() {\r\n        return false;\r\n    }\r\n\r\n// Support: IE <=9 - 11+\r\n// focus() and blur() are asynchronous, except when they are no-op.\r\n// So expect focus to be synchronous when the element is already active,\r\n// and blur to be synchronous when the element is not already active.\r\n// (focus and blur are always synchronous in other supported browsers,\r\n// this just defines when we can count on it).\r\n    function expectSync( elem, type ) {\r\n        return ( elem === safeActiveElement() ) === ( type === \"focus\" );\r\n    }\r\n\r\n// Support: IE <=9 only\r\n// Accessing document.activeElement can throw unexpectedly\r\n// https://bugs.jquery.com/ticket/13393\r\n    function safeActiveElement() {\r\n        try {\r\n            return document.activeElement;\r\n        } catch ( err ) { }\r\n    }\r\n\r\n    function on( elem, types, selector, data, fn, one ) {\r\n        var origFn, type;\r\n\r\n        // Types can be a map of types/handlers\r\n        if ( typeof types === \"object\" ) {\r\n\r\n            // ( types-Object, selector, data )\r\n            if ( typeof selector !== \"string\" ) {\r\n\r\n                // ( types-Object, data )\r\n                data = data || selector;\r\n                selector = undefined;\r\n            }\r\n            for ( type in types ) {\r\n                on( elem, type, selector, data, types[ type ], one );\r\n            }\r\n            return elem;\r\n        }\r\n\r\n        if ( data == null && fn == null ) {\r\n\r\n            // ( types, fn )\r\n            fn = selector;\r\n            data = selector = undefined;\r\n        } else if ( fn == null ) {\r\n            if ( typeof selector === \"string\" ) {\r\n\r\n                // ( types, selector, fn )\r\n                fn = data;\r\n                data = undefined;\r\n            } else {\r\n\r\n                // ( types, data, fn )\r\n                fn = data;\r\n                data = selector;\r\n                selector = undefined;\r\n            }\r\n        }\r\n        if ( fn === false ) {\r\n            fn = returnFalse;\r\n        } else if ( !fn ) {\r\n            return elem;\r\n        }\r\n\r\n        if ( one === 1 ) {\r\n            origFn = fn;\r\n            fn = function( event ) {\r\n\r\n                // Can use an empty set, since event contains the info\r\n                jQuery().off( event );\r\n                return origFn.apply( this, arguments );\r\n            };\r\n\r\n            // Use same guid so caller can remove using origFn\r\n            fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\r\n        }\r\n        return elem.each( function() {\r\n            jQuery.event.add( this, types, fn, data, selector );\r\n        } );\r\n    }\r\n\r\n    /*\r\n * Helper functions for managing events -- not part of the public interface.\r\n * Props to Dean Edwards' addEvent library for many of the ideas.\r\n */\r\n    jQuery.event = {\r\n\r\n        global: {},\r\n\r\n        add: function( elem, types, handler, data, selector ) {\r\n\r\n            var handleObjIn, eventHandle, tmp,\r\n                events, t, handleObj,\r\n                special, handlers, type, namespaces, origType,\r\n                elemData = dataPriv.get( elem );\r\n\r\n            // Only attach events to objects that accept data\r\n            if ( !acceptData( elem ) ) {\r\n                return;\r\n            }\r\n\r\n            // Caller can pass in an object of custom data in lieu of the handler\r\n            if ( handler.handler ) {\r\n                handleObjIn = handler;\r\n                handler = handleObjIn.handler;\r\n                selector = handleObjIn.selector;\r\n            }\r\n\r\n            // Ensure that invalid selectors throw exceptions at attach time\r\n            // Evaluate against documentElement in case elem is a non-element node (e.g., document)\r\n            if ( selector ) {\r\n                jQuery.find.matchesSelector( documentElement, selector );\r\n            }\r\n\r\n            // Make sure that the handler has a unique ID, used to find/remove it later\r\n            if ( !handler.guid ) {\r\n                handler.guid = jQuery.guid++;\r\n            }\r\n\r\n            // Init the element's event structure and main handler, if this is the first\r\n            if ( !( events = elemData.events ) ) {\r\n                events = elemData.events = Object.create( null );\r\n            }\r\n            if ( !( eventHandle = elemData.handle ) ) {\r\n                eventHandle = elemData.handle = function( e ) {\r\n\r\n                    // Discard the second event of a jQuery.event.trigger() and\r\n                    // when an event is called after a page has unloaded\r\n                    return typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\r\n                        jQuery.event.dispatch.apply( elem, arguments ) : undefined;\r\n                };\r\n            }\r\n\r\n            // Handle multiple events separated by a space\r\n            types = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\r\n            t = types.length;\r\n            while ( t-- ) {\r\n                tmp = rtypenamespace.exec( types[ t ] ) || [];\r\n                type = origType = tmp[ 1 ];\r\n                namespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\r\n\r\n                // There *must* be a type, no attaching namespace-only handlers\r\n                if ( !type ) {\r\n                    continue;\r\n                }\r\n\r\n                // If event changes its type, use the special event handlers for the changed type\r\n                special = jQuery.event.special[ type ] || {};\r\n\r\n                // If selector defined, determine special event api type, otherwise given type\r\n                type = ( selector ? special.delegateType : special.bindType ) || type;\r\n\r\n                // Update special based on newly reset type\r\n                special = jQuery.event.special[ type ] || {};\r\n\r\n                // handleObj is passed to all event handlers\r\n                handleObj = jQuery.extend( {\r\n                    type: type,\r\n                    origType: origType,\r\n                    data: data,\r\n                    handler: handler,\r\n                    guid: handler.guid,\r\n                    selector: selector,\r\n                    needsContext: selector && jQuery.expr.match.needsContext.test( selector ),\r\n                    namespace: namespaces.join( \".\" )\r\n                }, handleObjIn );\r\n\r\n                // Init the event handler queue if we're the first\r\n                if ( !( handlers = events[ type ] ) ) {\r\n                    handlers = events[ type ] = [];\r\n                    handlers.delegateCount = 0;\r\n\r\n                    // Only use addEventListener if the special events handler returns false\r\n                    if ( !special.setup ||\r\n                        special.setup.call( elem, data, namespaces, eventHandle ) === false ) {\r\n\r\n                        if ( elem.addEventListener ) {\r\n                            elem.addEventListener( type, eventHandle );\r\n                        }\r\n                    }\r\n                }\r\n\r\n                if ( special.add ) {\r\n                    special.add.call( elem, handleObj );\r\n\r\n                    if ( !handleObj.handler.guid ) {\r\n                        handleObj.handler.guid = handler.guid;\r\n                    }\r\n                }\r\n\r\n                // Add to the element's handler list, delegates in front\r\n                if ( selector ) {\r\n                    handlers.splice( handlers.delegateCount++, 0, handleObj );\r\n                } else {\r\n                    handlers.push( handleObj );\r\n                }\r\n\r\n                // Keep track of which events have ever been used, for event optimization\r\n                jQuery.event.global[ type ] = true;\r\n            }\r\n\r\n        },\r\n\r\n        // Detach an event or set of events from an element\r\n        remove: function( elem, types, handler, selector, mappedTypes ) {\r\n\r\n            var j, origCount, tmp,\r\n                events, t, handleObj,\r\n                special, handlers, type, namespaces, origType,\r\n                elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\r\n\r\n            if ( !elemData || !( events = elemData.events ) ) {\r\n                return;\r\n            }\r\n\r\n            // Once for each type.namespace in types; type may be omitted\r\n            types = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\r\n            t = types.length;\r\n            while ( t-- ) {\r\n                tmp = rtypenamespace.exec( types[ t ] ) || [];\r\n                type = origType = tmp[ 1 ];\r\n                namespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\r\n\r\n                // Unbind all events (on this namespace, if provided) for the element\r\n                if ( !type ) {\r\n                    for ( type in events ) {\r\n                        jQuery.event.remove( elem, type + types[ t ], handler, selector, true );\r\n                    }\r\n                    continue;\r\n                }\r\n\r\n                special = jQuery.event.special[ type ] || {};\r\n                type = ( selector ? special.delegateType : special.bindType ) || type;\r\n                handlers = events[ type ] || [];\r\n                tmp = tmp[ 2 ] &&\r\n                    new RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\r\n\r\n                // Remove matching events\r\n                origCount = j = handlers.length;\r\n                while ( j-- ) {\r\n                    handleObj = handlers[ j ];\r\n\r\n                    if ( ( mappedTypes || origType === handleObj.origType ) &&\r\n                        ( !handler || handler.guid === handleObj.guid ) &&\r\n                        ( !tmp || tmp.test( handleObj.namespace ) ) &&\r\n                        ( !selector || selector === handleObj.selector ||\r\n                            selector === \"**\" && handleObj.selector ) ) {\r\n                        handlers.splice( j, 1 );\r\n\r\n                        if ( handleObj.selector ) {\r\n                            handlers.delegateCount--;\r\n                        }\r\n                        if ( special.remove ) {\r\n                            special.remove.call( elem, handleObj );\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // Remove generic event handler if we removed something and no more handlers exist\r\n                // (avoids potential for endless recursion during removal of special event handlers)\r\n                if ( origCount && !handlers.length ) {\r\n                    if ( !special.teardown ||\r\n                        special.teardown.call( elem, namespaces, elemData.handle ) === false ) {\r\n\r\n                        jQuery.removeEvent( elem, type, elemData.handle );\r\n                    }\r\n\r\n                    delete events[ type ];\r\n                }\r\n            }\r\n\r\n            // Remove data and the expando if it's no longer used\r\n            if ( jQuery.isEmptyObject( events ) ) {\r\n                dataPriv.remove( elem, \"handle events\" );\r\n            }\r\n        },\r\n\r\n        dispatch: function( nativeEvent ) {\r\n\r\n            var i, j, ret, matched, handleObj, handlerQueue,\r\n                args = new Array( arguments.length ),\r\n\r\n                // Make a writable jQuery.Event from the native event object\r\n                event = jQuery.event.fix( nativeEvent ),\r\n\r\n                handlers = (\r\n                    dataPriv.get( this, \"events\" ) || Object.create( null )\r\n                )[ event.type ] || [],\r\n                special = jQuery.event.special[ event.type ] || {};\r\n\r\n            // Use the fix-ed jQuery.Event rather than the (read-only) native event\r\n            args[ 0 ] = event;\r\n\r\n            for ( i = 1; i < arguments.length; i++ ) {\r\n                args[ i ] = arguments[ i ];\r\n            }\r\n\r\n            event.delegateTarget = this;\r\n\r\n            // Call the preDispatch hook for the mapped type, and let it bail if desired\r\n            if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\r\n                return;\r\n            }\r\n\r\n            // Determine handlers\r\n            handlerQueue = jQuery.event.handlers.call( this, event, handlers );\r\n\r\n            // Run delegates first; they may want to stop propagation beneath us\r\n            i = 0;\r\n            while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\r\n                event.currentTarget = matched.elem;\r\n\r\n                j = 0;\r\n                while ( ( handleObj = matched.handlers[ j++ ] ) &&\r\n                !event.isImmediatePropagationStopped() ) {\r\n\r\n                    // If the event is namespaced, then each handler is only invoked if it is\r\n                    // specially universal or its namespaces are a superset of the event's.\r\n                    if ( !event.rnamespace || handleObj.namespace === false ||\r\n                        event.rnamespace.test( handleObj.namespace ) ) {\r\n\r\n                        event.handleObj = handleObj;\r\n                        event.data = handleObj.data;\r\n\r\n                        ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\r\n                            handleObj.handler ).apply( matched.elem, args );\r\n\r\n                        if ( ret !== undefined ) {\r\n                            if ( ( event.result = ret ) === false ) {\r\n                                event.preventDefault();\r\n                                event.stopPropagation();\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            // Call the postDispatch hook for the mapped type\r\n            if ( special.postDispatch ) {\r\n                special.postDispatch.call( this, event );\r\n            }\r\n\r\n            return event.result;\r\n        },\r\n\r\n        handlers: function( event, handlers ) {\r\n            var i, handleObj, sel, matchedHandlers, matchedSelectors,\r\n                handlerQueue = [],\r\n                delegateCount = handlers.delegateCount,\r\n                cur = event.target;\r\n\r\n            // Find delegate handlers\r\n            if ( delegateCount &&\r\n\r\n                // Support: IE <=9\r\n                // Black-hole SVG <use> instance trees (trac-13180)\r\n                cur.nodeType &&\r\n\r\n                // Support: Firefox <=42\r\n                // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\r\n                // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\r\n                // Support: IE 11 only\r\n                // ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\r\n                !( event.type === \"click\" && event.button >= 1 ) ) {\r\n\r\n                for ( ; cur !== this; cur = cur.parentNode || this ) {\r\n\r\n                    // Don't check non-elements (#13208)\r\n                    // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\r\n                    if ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\r\n                        matchedHandlers = [];\r\n                        matchedSelectors = {};\r\n                        for ( i = 0; i < delegateCount; i++ ) {\r\n                            handleObj = handlers[ i ];\r\n\r\n                            // Don't conflict with Object.prototype properties (#13203)\r\n                            sel = handleObj.selector + \" \";\r\n\r\n                            if ( matchedSelectors[ sel ] === undefined ) {\r\n                                matchedSelectors[ sel ] = handleObj.needsContext ?\r\n                                    jQuery( sel, this ).index( cur ) > -1 :\r\n                                    jQuery.find( sel, this, null, [ cur ] ).length;\r\n                            }\r\n                            if ( matchedSelectors[ sel ] ) {\r\n                                matchedHandlers.push( handleObj );\r\n                            }\r\n                        }\r\n                        if ( matchedHandlers.length ) {\r\n                            handlerQueue.push( { elem: cur, handlers: matchedHandlers } );\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            // Add the remaining (directly-bound) handlers\r\n            cur = this;\r\n            if ( delegateCount < handlers.length ) {\r\n                handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\r\n            }\r\n\r\n            return handlerQueue;\r\n        },\r\n\r\n        addProp: function( name, hook ) {\r\n            Object.defineProperty( jQuery.Event.prototype, name, {\r\n                enumerable: true,\r\n                configurable: true,\r\n\r\n                get: isFunction( hook ) ?\r\n                    function() {\r\n                        if ( this.originalEvent ) {\r\n                            return hook( this.originalEvent );\r\n                        }\r\n                    } :\r\n                    function() {\r\n                        if ( this.originalEvent ) {\r\n                            return this.originalEvent[ name ];\r\n                        }\r\n                    },\r\n\r\n                set: function( value ) {\r\n                    Object.defineProperty( this, name, {\r\n                        enumerable: true,\r\n                        configurable: true,\r\n                        writable: true,\r\n                        value: value\r\n                    } );\r\n                }\r\n            } );\r\n        },\r\n\r\n        fix: function( originalEvent ) {\r\n            return originalEvent[ jQuery.expando ] ?\r\n                originalEvent :\r\n                new jQuery.Event( originalEvent );\r\n        },\r\n\r\n        special: {\r\n            load: {\r\n\r\n                // Prevent triggered image.load events from bubbling to window.load\r\n                noBubble: true\r\n            },\r\n            click: {\r\n\r\n                // Utilize native event to ensure correct state for checkable inputs\r\n                setup: function( data ) {\r\n\r\n                    // For mutual compressibility with _default, replace `this` access with a local var.\r\n                    // `|| data` is dead code meant only to preserve the variable through minification.\r\n                    var el = this || data;\r\n\r\n                    // Claim the first handler\r\n                    if ( rcheckableType.test( el.type ) &&\r\n                        el.click && nodeName( el, \"input\" ) ) {\r\n\r\n                        // dataPriv.set( el, \"click\", ... )\r\n                        leverageNative( el, \"click\", returnTrue );\r\n                    }\r\n\r\n                    // Return false to allow normal processing in the caller\r\n                    return false;\r\n                },\r\n                trigger: function( data ) {\r\n\r\n                    // For mutual compressibility with _default, replace `this` access with a local var.\r\n                    // `|| data` is dead code meant only to preserve the variable through minification.\r\n                    var el = this || data;\r\n\r\n                    // Force setup before triggering a click\r\n                    if ( rcheckableType.test( el.type ) &&\r\n                        el.click && nodeName( el, \"input\" ) ) {\r\n\r\n                        leverageNative( el, \"click\" );\r\n                    }\r\n\r\n                    // Return non-false to allow normal event-path propagation\r\n                    return true;\r\n                },\r\n\r\n                // For cross-browser consistency, suppress native .click() on links\r\n                // Also prevent it if we're currently inside a leveraged native-event stack\r\n                _default: function( event ) {\r\n                    var target = event.target;\r\n                    return rcheckableType.test( target.type ) &&\r\n                        target.click && nodeName( target, \"input\" ) &&\r\n                        dataPriv.get( target, \"click\" ) ||\r\n                        nodeName( target, \"a\" );\r\n                }\r\n            },\r\n\r\n            beforeunload: {\r\n                postDispatch: function( event ) {\r\n\r\n                    // Support: Firefox 20+\r\n                    // Firefox doesn't alert if the returnValue field is not set.\r\n                    if ( event.result !== undefined && event.originalEvent ) {\r\n                        event.originalEvent.returnValue = event.result;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    };\r\n\r\n// Ensure the presence of an event listener that handles manually-triggered\r\n// synthetic events by interrupting progress until reinvoked in response to\r\n// *native* events that it fires directly, ensuring that state changes have\r\n// already occurred before other listeners are invoked.\r\n    function leverageNative( el, type, expectSync ) {\r\n\r\n        // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add\r\n        if ( !expectSync ) {\r\n            if ( dataPriv.get( el, type ) === undefined ) {\r\n                jQuery.event.add( el, type, returnTrue );\r\n            }\r\n            return;\r\n        }\r\n\r\n        // Register the controller as a special universal handler for all event namespaces\r\n        dataPriv.set( el, type, false );\r\n        jQuery.event.add( el, type, {\r\n            namespace: false,\r\n            handler: function( event ) {\r\n                var notAsync, result,\r\n                    saved = dataPriv.get( this, type );\r\n\r\n                if ( ( event.isTrigger & 1 ) && this[ type ] ) {\r\n\r\n                    // Interrupt processing of the outer synthetic .trigger()ed event\r\n                    // Saved data should be false in such cases, but might be a leftover capture object\r\n                    // from an async native handler (gh-4350)\r\n                    if ( !saved.length ) {\r\n\r\n                        // Store arguments for use when handling the inner native event\r\n                        // There will always be at least one argument (an event object), so this array\r\n                        // will not be confused with a leftover capture object.\r\n                        saved = slice.call( arguments );\r\n                        dataPriv.set( this, type, saved );\r\n\r\n                        // Trigger the native event and capture its result\r\n                        // Support: IE <=9 - 11+\r\n                        // focus() and blur() are asynchronous\r\n                        notAsync = expectSync( this, type );\r\n                        this[ type ]();\r\n                        result = dataPriv.get( this, type );\r\n                        if ( saved !== result || notAsync ) {\r\n                            dataPriv.set( this, type, false );\r\n                        } else {\r\n                            result = {};\r\n                        }\r\n                        if ( saved !== result ) {\r\n\r\n                            // Cancel the outer synthetic event\r\n                            event.stopImmediatePropagation();\r\n                            event.preventDefault();\r\n\r\n                            // Support: Chrome 86+\r\n                            // In Chrome, if an element having a focusout handler is blurred by\r\n                            // clicking outside of it, it invokes the handler synchronously. If\r\n                            // that handler calls `.remove()` on the element, the data is cleared,\r\n                            // leaving `result` undefined. We need to guard against this.\r\n                            return result && result.value;\r\n                        }\r\n\r\n                        // If this is an inner synthetic event for an event with a bubbling surrogate\r\n                        // (focus or blur), assume that the surrogate already propagated from triggering the\r\n                        // native event and prevent that from happening again here.\r\n                        // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\r\n                        // bubbling surrogate propagates *after* the non-bubbling base), but that seems\r\n                        // less bad than duplication.\r\n                    } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\r\n                        event.stopPropagation();\r\n                    }\r\n\r\n                    // If this is a native event triggered above, everything is now in order\r\n                    // Fire an inner synthetic event with the original arguments\r\n                } else if ( saved.length ) {\r\n\r\n                    // ...and capture the result\r\n                    dataPriv.set( this, type, {\r\n                        value: jQuery.event.trigger(\r\n\r\n                            // Support: IE <=9 - 11+\r\n                            // Extend with the prototype to reset the above stopImmediatePropagation()\r\n                            jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),\r\n                            saved.slice( 1 ),\r\n                            this\r\n                        )\r\n                    } );\r\n\r\n                    // Abort handling of the native event\r\n                    event.stopImmediatePropagation();\r\n                }\r\n            }\r\n        } );\r\n    }\r\n\r\n    jQuery.removeEvent = function( elem, type, handle ) {\r\n\r\n        // This \"if\" is needed for plain objects\r\n        if ( elem.removeEventListener ) {\r\n            elem.removeEventListener( type, handle );\r\n        }\r\n    };\r\n\r\n    jQuery.Event = function( src, props ) {\r\n\r\n        // Allow instantiation without the 'new' keyword\r\n        if ( !( this instanceof jQuery.Event ) ) {\r\n            return new jQuery.Event( src, props );\r\n        }\r\n\r\n        // Event object\r\n        if ( src && src.type ) {\r\n            this.originalEvent = src;\r\n            this.type = src.type;\r\n\r\n            // Events bubbling up the document may have been marked as prevented\r\n            // by a handler lower down the tree; reflect the correct value.\r\n            this.isDefaultPrevented = src.defaultPrevented ||\r\n            src.defaultPrevented === undefined &&\r\n\r\n            // Support: Android <=2.3 only\r\n            src.returnValue === false ?\r\n                returnTrue :\r\n                returnFalse;\r\n\r\n            // Create target properties\r\n            // Support: Safari <=6 - 7 only\r\n            // Target should not be a text node (#504, #13143)\r\n            this.target = ( src.target && src.target.nodeType === 3 ) ?\r\n                src.target.parentNode :\r\n                src.target;\r\n\r\n            this.currentTarget = src.currentTarget;\r\n            this.relatedTarget = src.relatedTarget;\r\n\r\n            // Event type\r\n        } else {\r\n            this.type = src;\r\n        }\r\n\r\n        // Put explicitly provided properties onto the event object\r\n        if ( props ) {\r\n            jQuery.extend( this, props );\r\n        }\r\n\r\n        // Create a timestamp if incoming event doesn't have one\r\n        this.timeStamp = src && src.timeStamp || Date.now();\r\n\r\n        // Mark it as fixed\r\n        this[ jQuery.expando ] = true;\r\n    };\r\n\r\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\r\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\r\n    jQuery.Event.prototype = {\r\n        constructor: jQuery.Event,\r\n        isDefaultPrevented: returnFalse,\r\n        isPropagationStopped: returnFalse,\r\n        isImmediatePropagationStopped: returnFalse,\r\n        isSimulated: false,\r\n\r\n        preventDefault: function() {\r\n            var e = this.originalEvent;\r\n\r\n            this.isDefaultPrevented = returnTrue;\r\n\r\n            if ( e && !this.isSimulated ) {\r\n                e.preventDefault();\r\n            }\r\n        },\r\n        stopPropagation: function() {\r\n            var e = this.originalEvent;\r\n\r\n            this.isPropagationStopped = returnTrue;\r\n\r\n            if ( e && !this.isSimulated ) {\r\n                e.stopPropagation();\r\n            }\r\n        },\r\n        stopImmediatePropagation: function() {\r\n            var e = this.originalEvent;\r\n\r\n            this.isImmediatePropagationStopped = returnTrue;\r\n\r\n            if ( e && !this.isSimulated ) {\r\n                e.stopImmediatePropagation();\r\n            }\r\n\r\n            this.stopPropagation();\r\n        }\r\n    };\r\n\r\n// Includes all common event props including KeyEvent and MouseEvent specific props\r\n    jQuery.each( {\r\n        altKey: true,\r\n        bubbles: true,\r\n        cancelable: true,\r\n        changedTouches: true,\r\n        ctrlKey: true,\r\n        detail: true,\r\n        eventPhase: true,\r\n        metaKey: true,\r\n        pageX: true,\r\n        pageY: true,\r\n        shiftKey: true,\r\n        view: true,\r\n        \"char\": true,\r\n        code: true,\r\n        charCode: true,\r\n        key: true,\r\n        keyCode: true,\r\n        button: true,\r\n        buttons: true,\r\n        clientX: true,\r\n        clientY: true,\r\n        offsetX: true,\r\n        offsetY: true,\r\n        pointerId: true,\r\n        pointerType: true,\r\n        screenX: true,\r\n        screenY: true,\r\n        targetTouches: true,\r\n        toElement: true,\r\n        touches: true,\r\n        which: true\r\n    }, jQuery.event.addProp );\r\n\r\n    jQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\r\n        jQuery.event.special[ type ] = {\r\n\r\n            // Utilize native event if possible so blur/focus sequence is correct\r\n            setup: function() {\r\n\r\n                // Claim the first handler\r\n                // dataPriv.set( this, \"focus\", ... )\r\n                // dataPriv.set( this, \"blur\", ... )\r\n                leverageNative( this, type, expectSync );\r\n\r\n                // Return false to allow normal processing in the caller\r\n                return false;\r\n            },\r\n            trigger: function() {\r\n\r\n                // Force setup before trigger\r\n                leverageNative( this, type );\r\n\r\n                // Return non-false to allow normal event-path propagation\r\n                return true;\r\n            },\r\n\r\n            // Suppress native focus or blur as it's already being fired\r\n            // in leverageNative.\r\n            _default: function() {\r\n                return true;\r\n            },\r\n\r\n            delegateType: delegateType\r\n        };\r\n    } );\r\n\r\n// Create mouseenter/leave events using mouseover/out and event-time checks\r\n// so that event delegation works in jQuery.\r\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\r\n//\r\n// Support: Safari 7 only\r\n// Safari sends mouseenter too often; see:\r\n// https://bugs.chromium.org/p/chromium/issues/detail?id=470258\r\n// for the description of the bug (it existed in older Chrome versions as well).\r\n    jQuery.each( {\r\n        mouseenter: \"mouseover\",\r\n        mouseleave: \"mouseout\",\r\n        pointerenter: \"pointerover\",\r\n        pointerleave: \"pointerout\"\r\n    }, function( orig, fix ) {\r\n        jQuery.event.special[ orig ] = {\r\n            delegateType: fix,\r\n            bindType: fix,\r\n\r\n            handle: function( event ) {\r\n                var ret,\r\n                    target = this,\r\n                    related = event.relatedTarget,\r\n                    handleObj = event.handleObj;\r\n\r\n                // For mouseenter/leave call the handler if related is outside the target.\r\n                // NB: No relatedTarget if the mouse left/entered the browser window\r\n                if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\r\n                    event.type = handleObj.origType;\r\n                    ret = handleObj.handler.apply( this, arguments );\r\n                    event.type = fix;\r\n                }\r\n                return ret;\r\n            }\r\n        };\r\n    } );\r\n\r\n    jQuery.fn.extend( {\r\n\r\n        on: function( types, selector, data, fn ) {\r\n            return on( this, types, selector, data, fn );\r\n        },\r\n        one: function( types, selector, data, fn ) {\r\n            return on( this, types, selector, data, fn, 1 );\r\n        },\r\n        off: function( types, selector, fn ) {\r\n            var handleObj, type;\r\n            if ( types && types.preventDefault && types.handleObj ) {\r\n\r\n                // ( event )  dispatched jQuery.Event\r\n                handleObj = types.handleObj;\r\n                jQuery( types.delegateTarget ).off(\r\n                    handleObj.namespace ?\r\n                        handleObj.origType + \".\" + handleObj.namespace :\r\n                        handleObj.origType,\r\n                    handleObj.selector,\r\n                    handleObj.handler\r\n                );\r\n                return this;\r\n            }\r\n            if ( typeof types === \"object\" ) {\r\n\r\n                // ( types-object [, selector] )\r\n                for ( type in types ) {\r\n                    this.off( type, selector, types[ type ] );\r\n                }\r\n                return this;\r\n            }\r\n            if ( selector === false || typeof selector === \"function\" ) {\r\n\r\n                // ( types [, fn] )\r\n                fn = selector;\r\n                selector = undefined;\r\n            }\r\n            if ( fn === false ) {\r\n                fn = returnFalse;\r\n            }\r\n            return this.each( function() {\r\n                jQuery.event.remove( this, types, fn, selector );\r\n            } );\r\n        }\r\n    } );\r\n\r\n\r\n    var\r\n\r\n        // Support: IE <=10 - 11, Edge 12 - 13 only\r\n        // In IE/Edge using regex groups here causes severe slowdowns.\r\n        // See https://connect.microsoft.com/IE/feedback/details/1736512/\r\n        rnoInnerhtml = /<script|<style|<link/i,\r\n\r\n        // checked=\"checked\" or checked\r\n        rchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\r\n        rcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g;\r\n\r\n// Prefer a tbody over its parent table for containing new rows\r\n    function manipulationTarget( elem, content ) {\r\n        if ( nodeName( elem, \"table\" ) &&\r\n            nodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\r\n\r\n            return jQuery( elem ).children( \"tbody\" )[ 0 ] || elem;\r\n        }\r\n\r\n        return elem;\r\n    }\r\n\r\n// Replace/restore the type attribute of script elements for safe DOM manipulation\r\n    function disableScript( elem ) {\r\n        elem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\r\n        return elem;\r\n    }\r\n    function restoreScript( elem ) {\r\n        if ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\r\n            elem.type = elem.type.slice( 5 );\r\n        } else {\r\n            elem.removeAttribute( \"type\" );\r\n        }\r\n\r\n        return elem;\r\n    }\r\n\r\n    function cloneCopyEvent( src, dest ) {\r\n        var i, l, type, pdataOld, udataOld, udataCur, events;\r\n\r\n        if ( dest.nodeType !== 1 ) {\r\n            return;\r\n        }\r\n\r\n        // 1. Copy private data: events, handlers, etc.\r\n        if ( dataPriv.hasData( src ) ) {\r\n            pdataOld = dataPriv.get( src );\r\n            events = pdataOld.events;\r\n\r\n            if ( events ) {\r\n                dataPriv.remove( dest, \"handle events\" );\r\n\r\n                for ( type in events ) {\r\n                    for ( i = 0, l = events[ type ].length; i < l; i++ ) {\r\n                        jQuery.event.add( dest, type, events[ type ][ i ] );\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        // 2. Copy user data\r\n        if ( dataUser.hasData( src ) ) {\r\n            udataOld = dataUser.access( src );\r\n            udataCur = jQuery.extend( {}, udataOld );\r\n\r\n            dataUser.set( dest, udataCur );\r\n        }\r\n    }\r\n\r\n// Fix IE bugs, see support tests\r\n    function fixInput( src, dest ) {\r\n        var nodeName = dest.nodeName.toLowerCase();\r\n\r\n        // Fails to persist the checked state of a cloned checkbox or radio button.\r\n        if ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\r\n            dest.checked = src.checked;\r\n\r\n            // Fails to return the selected option to the default selected state when cloning options\r\n        } else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\r\n            dest.defaultValue = src.defaultValue;\r\n        }\r\n    }\r\n\r\n    function domManip( collection, args, callback, ignored ) {\r\n\r\n        // Flatten any nested arrays\r\n        args = flat( args );\r\n\r\n        var fragment, first, scripts, hasScripts, node, doc,\r\n            i = 0,\r\n            l = collection.length,\r\n            iNoClone = l - 1,\r\n            value = args[ 0 ],\r\n            valueIsFunction = isFunction( value );\r\n\r\n        // We can't cloneNode fragments that contain checked, in WebKit\r\n        if ( valueIsFunction ||\r\n            ( l > 1 && typeof value === \"string\" &&\r\n                !support.checkClone && rchecked.test( value ) ) ) {\r\n            return collection.each( function( index ) {\r\n                var self = collection.eq( index );\r\n                if ( valueIsFunction ) {\r\n                    args[ 0 ] = value.call( this, index, self.html() );\r\n                }\r\n                domManip( self, args, callback, ignored );\r\n            } );\r\n        }\r\n\r\n        if ( l ) {\r\n            fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\r\n            first = fragment.firstChild;\r\n\r\n            if ( fragment.childNodes.length === 1 ) {\r\n                fragment = first;\r\n            }\r\n\r\n            // Require either new content or an interest in ignored elements to invoke the callback\r\n            if ( first || ignored ) {\r\n                scripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\r\n                hasScripts = scripts.length;\r\n\r\n                // Use the original fragment for the last item\r\n                // instead of the first because it can end up\r\n                // being emptied incorrectly in certain situations (#8070).\r\n                for ( ; i < l; i++ ) {\r\n                    node = fragment;\r\n\r\n                    if ( i !== iNoClone ) {\r\n                        node = jQuery.clone( node, true, true );\r\n\r\n                        // Keep references to cloned scripts for later restoration\r\n                        if ( hasScripts ) {\r\n\r\n                            // Support: Android <=4.0 only, PhantomJS 1 only\r\n                            // push.apply(_, arraylike) throws on ancient WebKit\r\n                            jQuery.merge( scripts, getAll( node, \"script\" ) );\r\n                        }\r\n                    }\r\n\r\n                    callback.call( collection[ i ], node, i );\r\n                }\r\n\r\n                if ( hasScripts ) {\r\n                    doc = scripts[ scripts.length - 1 ].ownerDocument;\r\n\r\n                    // Reenable scripts\r\n                    jQuery.map( scripts, restoreScript );\r\n\r\n                    // Evaluate executable scripts on first document insertion\r\n                    for ( i = 0; i < hasScripts; i++ ) {\r\n                        node = scripts[ i ];\r\n                        if ( rscriptType.test( node.type || \"\" ) &&\r\n                            !dataPriv.access( node, \"globalEval\" ) &&\r\n                            jQuery.contains( doc, node ) ) {\r\n\r\n                            if ( node.src && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\r\n\r\n                                // Optional AJAX dependency, but won't run scripts if not present\r\n                                if ( jQuery._evalUrl && !node.noModule ) {\r\n                                    jQuery._evalUrl( node.src, {\r\n                                        nonce: node.nonce || node.getAttribute( \"nonce\" )\r\n                                    }, doc );\r\n                                }\r\n                            } else {\r\n                                DOMEval( node.textContent.replace( rcleanScript, \"\" ), node, doc );\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return collection;\r\n    }\r\n\r\n    function remove( elem, selector, keepData ) {\r\n        var node,\r\n            nodes = selector ? jQuery.filter( selector, elem ) : elem,\r\n            i = 0;\r\n\r\n        for ( ; ( node = nodes[ i ] ) != null; i++ ) {\r\n            if ( !keepData && node.nodeType === 1 ) {\r\n                jQuery.cleanData( getAll( node ) );\r\n            }\r\n\r\n            if ( node.parentNode ) {\r\n                if ( keepData && isAttached( node ) ) {\r\n                    setGlobalEval( getAll( node, \"script\" ) );\r\n                }\r\n                node.parentNode.removeChild( node );\r\n            }\r\n        }\r\n\r\n        return elem;\r\n    }\r\n\r\n    jQuery.extend( {\r\n        htmlPrefilter: function( html ) {\r\n            return html;\r\n        },\r\n\r\n        clone: function( elem, dataAndEvents, deepDataAndEvents ) {\r\n            var i, l, srcElements, destElements,\r\n                clone = elem.cloneNode( true ),\r\n                inPage = isAttached( elem );\r\n\r\n            // Fix IE cloning issues\r\n            if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\r\n                !jQuery.isXMLDoc( elem ) ) {\r\n\r\n                // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2\r\n                destElements = getAll( clone );\r\n                srcElements = getAll( elem );\r\n\r\n                for ( i = 0, l = srcElements.length; i < l; i++ ) {\r\n                    fixInput( srcElements[ i ], destElements[ i ] );\r\n                }\r\n            }\r\n\r\n            // Copy the events from the original to the clone\r\n            if ( dataAndEvents ) {\r\n                if ( deepDataAndEvents ) {\r\n                    srcElements = srcElements || getAll( elem );\r\n                    destElements = destElements || getAll( clone );\r\n\r\n                    for ( i = 0, l = srcElements.length; i < l; i++ ) {\r\n                        cloneCopyEvent( srcElements[ i ], destElements[ i ] );\r\n                    }\r\n                } else {\r\n                    cloneCopyEvent( elem, clone );\r\n                }\r\n            }\r\n\r\n            // Preserve script evaluation history\r\n            destElements = getAll( clone, \"script\" );\r\n            if ( destElements.length > 0 ) {\r\n                setGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\r\n            }\r\n\r\n            // Return the cloned set\r\n            return clone;\r\n        },\r\n\r\n        cleanData: function( elems ) {\r\n            var data, elem, type,\r\n                special = jQuery.event.special,\r\n                i = 0;\r\n\r\n            for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\r\n                if ( acceptData( elem ) ) {\r\n                    if ( ( data = elem[ dataPriv.expando ] ) ) {\r\n                        if ( data.events ) {\r\n                            for ( type in data.events ) {\r\n                                if ( special[ type ] ) {\r\n                                    jQuery.event.remove( elem, type );\r\n\r\n                                    // This is a shortcut to avoid jQuery.event.remove's overhead\r\n                                } else {\r\n                                    jQuery.removeEvent( elem, type, data.handle );\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        // Support: Chrome <=35 - 45+\r\n                        // Assign undefined instead of using delete, see Data#remove\r\n                        elem[ dataPriv.expando ] = undefined;\r\n                    }\r\n                    if ( elem[ dataUser.expando ] ) {\r\n\r\n                        // Support: Chrome <=35 - 45+\r\n                        // Assign undefined instead of using delete, see Data#remove\r\n                        elem[ dataUser.expando ] = undefined;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    } );\r\n\r\n    jQuery.fn.extend( {\r\n        detach: function( selector ) {\r\n            return remove( this, selector, true );\r\n        },\r\n\r\n        remove: function( selector ) {\r\n            return remove( this, selector );\r\n        },\r\n\r\n        text: function( value ) {\r\n            return access( this, function( value ) {\r\n                return value === undefined ?\r\n                    jQuery.text( this ) :\r\n                    this.empty().each( function() {\r\n                        if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\r\n                            this.textContent = value;\r\n                        }\r\n                    } );\r\n            }, null, value, arguments.length );\r\n        },\r\n\r\n        append: function() {\r\n            return domManip( this, arguments, function( elem ) {\r\n                if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\r\n                    var target = manipulationTarget( this, elem );\r\n                    target.appendChild( elem );\r\n                }\r\n            } );\r\n        },\r\n\r\n        prepend: function() {\r\n            return domManip( this, arguments, function( elem ) {\r\n                if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\r\n                    var target = manipulationTarget( this, elem );\r\n                    target.insertBefore( elem, target.firstChild );\r\n                }\r\n            } );\r\n        },\r\n\r\n        before: function() {\r\n            return domManip( this, arguments, function( elem ) {\r\n                if ( this.parentNode ) {\r\n                    this.parentNode.insertBefore( elem, this );\r\n                }\r\n            } );\r\n        },\r\n\r\n        after: function() {\r\n            return domManip( this, arguments, function( elem ) {\r\n                if ( this.parentNode ) {\r\n                    this.parentNode.insertBefore( elem, this.nextSibling );\r\n                }\r\n            } );\r\n        },\r\n\r\n        empty: function() {\r\n            var elem,\r\n                i = 0;\r\n\r\n            for ( ; ( elem = this[ i ] ) != null; i++ ) {\r\n                if ( elem.nodeType === 1 ) {\r\n\r\n                    // Prevent memory leaks\r\n                    jQuery.cleanData( getAll( elem, false ) );\r\n\r\n                    // Remove any remaining nodes\r\n                    elem.textContent = \"\";\r\n                }\r\n            }\r\n\r\n            return this;\r\n        },\r\n\r\n        clone: function( dataAndEvents, deepDataAndEvents ) {\r\n            dataAndEvents = dataAndEvents == null ? false : dataAndEvents;\r\n            deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\r\n\r\n            return this.map( function() {\r\n                return jQuery.clone( this, dataAndEvents, deepDataAndEvents );\r\n            } );\r\n        },\r\n\r\n        html: function( value ) {\r\n            return access( this, function( value ) {\r\n                var elem = this[ 0 ] || {},\r\n                    i = 0,\r\n                    l = this.length;\r\n\r\n                if ( value === undefined && elem.nodeType === 1 ) {\r\n                    return elem.innerHTML;\r\n                }\r\n\r\n                // See if we can take a shortcut and just use innerHTML\r\n                if ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\r\n                    !wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\r\n\r\n                    value = jQuery.htmlPrefilter( value );\r\n\r\n                    try {\r\n                        for ( ; i < l; i++ ) {\r\n                            elem = this[ i ] || {};\r\n\r\n                            // Remove element nodes and prevent memory leaks\r\n                            if ( elem.nodeType === 1 ) {\r\n                                jQuery.cleanData( getAll( elem, false ) );\r\n                                elem.innerHTML = value;\r\n                            }\r\n                        }\r\n\r\n                        elem = 0;\r\n\r\n                        // If using innerHTML throws an exception, use the fallback method\r\n                    } catch ( e ) {}\r\n                }\r\n\r\n                if ( elem ) {\r\n                    this.empty().append( value );\r\n                }\r\n            }, null, value, arguments.length );\r\n        },\r\n\r\n        replaceWith: function() {\r\n            var ignored = [];\r\n\r\n            // Make the changes, replacing each non-ignored context element with the new content\r\n            return domManip( this, arguments, function( elem ) {\r\n                var parent = this.parentNode;\r\n\r\n                if ( jQuery.inArray( this, ignored ) < 0 ) {\r\n                    jQuery.cleanData( getAll( this ) );\r\n                    if ( parent ) {\r\n                        parent.replaceChild( elem, this );\r\n                    }\r\n                }\r\n\r\n                // Force callback invocation\r\n            }, ignored );\r\n        }\r\n    } );\r\n\r\n    jQuery.each( {\r\n        appendTo: \"append\",\r\n        prependTo: \"prepend\",\r\n        insertBefore: \"before\",\r\n        insertAfter: \"after\",\r\n        replaceAll: \"replaceWith\"\r\n    }, function( name, original ) {\r\n        jQuery.fn[ name ] = function( selector ) {\r\n            var elems,\r\n                ret = [],\r\n                insert = jQuery( selector ),\r\n                last = insert.length - 1,\r\n                i = 0;\r\n\r\n            for ( ; i <= last; i++ ) {\r\n                elems = i === last ? this : this.clone( true );\r\n                jQuery( insert[ i ] )[ original ]( elems );\r\n\r\n                // Support: Android <=4.0 only, PhantomJS 1 only\r\n                // .get() because push.apply(_, arraylike) throws on ancient WebKit\r\n                push.apply( ret, elems.get() );\r\n            }\r\n\r\n            return this.pushStack( ret );\r\n        };\r\n    } );\r\n    var rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\r\n\r\n    var getStyles = function( elem ) {\r\n\r\n        // Support: IE <=11 only, Firefox <=30 (#15098, #14150)\r\n        // IE throws on elements created in popups\r\n        // FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\r\n        var view = elem.ownerDocument.defaultView;\r\n\r\n        if ( !view || !view.opener ) {\r\n            view = window;\r\n        }\r\n\r\n        return view.getComputedStyle( elem );\r\n    };\r\n\r\n    var swap = function( elem, options, callback ) {\r\n        var ret, name,\r\n            old = {};\r\n\r\n        // Remember the old values, and insert the new ones\r\n        for ( name in options ) {\r\n            old[ name ] = elem.style[ name ];\r\n            elem.style[ name ] = options[ name ];\r\n        }\r\n\r\n        ret = callback.call( elem );\r\n\r\n        // Revert the old values\r\n        for ( name in options ) {\r\n            elem.style[ name ] = old[ name ];\r\n        }\r\n\r\n        return ret;\r\n    };\r\n\r\n\r\n    var rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\r\n\r\n\r\n\r\n    ( function() {\r\n\r\n        // Executing both pixelPosition & boxSizingReliable tests require only one layout\r\n        // so they're executed at the same time to save the second computation.\r\n        function computeStyleTests() {\r\n\r\n            // This is a singleton, we need to execute it only once\r\n            if ( !div ) {\r\n                return;\r\n            }\r\n\r\n            container.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\r\n                \"margin-top:1px;padding:0;border:0\";\r\n            div.style.cssText =\r\n                \"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\r\n                \"margin:auto;border:1px;padding:1px;\" +\r\n                \"width:60%;top:1%\";\r\n            documentElement.appendChild( container ).appendChild( div );\r\n\r\n            var divStyle = window.getComputedStyle( div );\r\n            pixelPositionVal = divStyle.top !== \"1%\";\r\n\r\n            // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\r\n            reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;\r\n\r\n            // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\r\n            // Some styles come back with percentage values, even though they shouldn't\r\n            div.style.right = \"60%\";\r\n            pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\r\n\r\n            // Support: IE 9 - 11 only\r\n            // Detect misreporting of content dimensions for box-sizing:border-box elements\r\n            boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\r\n\r\n            // Support: IE 9 only\r\n            // Detect overflow:scroll screwiness (gh-3699)\r\n            // Support: Chrome <=64\r\n            // Don't get tricked when zoom affects offsetWidth (gh-4029)\r\n            div.style.position = \"absolute\";\r\n            scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;\r\n\r\n            documentElement.removeChild( container );\r\n\r\n            // Nullify the div so it wouldn't be stored in the memory and\r\n            // it will also be a sign that checks already performed\r\n            div = null;\r\n        }\r\n\r\n        function roundPixelMeasures( measure ) {\r\n            return Math.round( parseFloat( measure ) );\r\n        }\r\n\r\n        var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\r\n            reliableTrDimensionsVal, reliableMarginLeftVal,\r\n            container = document.createElement( \"div\" ),\r\n            div = document.createElement( \"div\" );\r\n\r\n        // Finish early in limited (non-browser) environments\r\n        if ( !div.style ) {\r\n            return;\r\n        }\r\n\r\n        // Support: IE <=9 - 11 only\r\n        // Style of cloned element affects source element cloned (#8908)\r\n        div.style.backgroundClip = \"content-box\";\r\n        div.cloneNode( true ).style.backgroundClip = \"\";\r\n        support.clearCloneStyle = div.style.backgroundClip === \"content-box\";\r\n\r\n        jQuery.extend( support, {\r\n            boxSizingReliable: function() {\r\n                computeStyleTests();\r\n                return boxSizingReliableVal;\r\n            },\r\n            pixelBoxStyles: function() {\r\n                computeStyleTests();\r\n                return pixelBoxStylesVal;\r\n            },\r\n            pixelPosition: function() {\r\n                computeStyleTests();\r\n                return pixelPositionVal;\r\n            },\r\n            reliableMarginLeft: function() {\r\n                computeStyleTests();\r\n                return reliableMarginLeftVal;\r\n            },\r\n            scrollboxSize: function() {\r\n                computeStyleTests();\r\n                return scrollboxSizeVal;\r\n            },\r\n\r\n            // Support: IE 9 - 11+, Edge 15 - 18+\r\n            // IE/Edge misreport `getComputedStyle` of table rows with width/height\r\n            // set in CSS while `offset*` properties report correct values.\r\n            // Behavior in IE 9 is more subtle than in newer versions & it passes\r\n            // some versions of this test; make sure not to make it pass there!\r\n            //\r\n            // Support: Firefox 70+\r\n            // Only Firefox includes border widths\r\n            // in computed dimensions. (gh-4529)\r\n            reliableTrDimensions: function() {\r\n                var table, tr, trChild, trStyle;\r\n                if ( reliableTrDimensionsVal == null ) {\r\n                    table = document.createElement( \"table\" );\r\n                    tr = document.createElement( \"tr\" );\r\n                    trChild = document.createElement( \"div\" );\r\n\r\n                    table.style.cssText = \"position:absolute;left:-11111px;border-collapse:separate\";\r\n                    tr.style.cssText = \"border:1px solid\";\r\n\r\n                    // Support: Chrome 86+\r\n                    // Height set through cssText does not get applied.\r\n                    // Computed height then comes back as 0.\r\n                    tr.style.height = \"1px\";\r\n                    trChild.style.height = \"9px\";\r\n\r\n                    // Support: Android 8 Chrome 86+\r\n                    // In our bodyBackground.html iframe,\r\n                    // display for all div elements is set to \"inline\",\r\n                    // which causes a problem only in Android 8 Chrome 86.\r\n                    // Ensuring the div is display: block\r\n                    // gets around this issue.\r\n                    trChild.style.display = \"block\";\r\n\r\n                    documentElement\r\n                        .appendChild( table )\r\n                        .appendChild( tr )\r\n                        .appendChild( trChild );\r\n\r\n                    trStyle = window.getComputedStyle( tr );\r\n                    reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +\r\n                        parseInt( trStyle.borderTopWidth, 10 ) +\r\n                        parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;\r\n\r\n                    documentElement.removeChild( table );\r\n                }\r\n                return reliableTrDimensionsVal;\r\n            }\r\n        } );\r\n    } )();\r\n\r\n\r\n    function curCSS( elem, name, computed ) {\r\n        var width, minWidth, maxWidth, ret,\r\n\r\n            // Support: Firefox 51+\r\n            // Retrieving style before computed somehow\r\n            // fixes an issue with getting wrong values\r\n            // on detached elements\r\n            style = elem.style;\r\n\r\n        computed = computed || getStyles( elem );\r\n\r\n        // getPropertyValue is needed for:\r\n        //   .css('filter') (IE 9 only, #12537)\r\n        //   .css('--customProperty) (#3144)\r\n        if ( computed ) {\r\n            ret = computed.getPropertyValue( name ) || computed[ name ];\r\n\r\n            if ( ret === \"\" && !isAttached( elem ) ) {\r\n                ret = jQuery.style( elem, name );\r\n            }\r\n\r\n            // A tribute to the \"awesome hack by Dean Edwards\"\r\n            // Android Browser returns percentage for some values,\r\n            // but width seems to be reliably pixels.\r\n            // This is against the CSSOM draft spec:\r\n            // https://drafts.csswg.org/cssom/#resolved-values\r\n            if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {\r\n\r\n                // Remember the original values\r\n                width = style.width;\r\n                minWidth = style.minWidth;\r\n                maxWidth = style.maxWidth;\r\n\r\n                // Put in the new values to get a computed value out\r\n                style.minWidth = style.maxWidth = style.width = ret;\r\n                ret = computed.width;\r\n\r\n                // Revert the changed values\r\n                style.width = width;\r\n                style.minWidth = minWidth;\r\n                style.maxWidth = maxWidth;\r\n            }\r\n        }\r\n\r\n        return ret !== undefined ?\r\n\r\n            // Support: IE <=9 - 11 only\r\n            // IE returns zIndex value as an integer.\r\n            ret + \"\" :\r\n            ret;\r\n    }\r\n\r\n\r\n    function addGetHookIf( conditionFn, hookFn ) {\r\n\r\n        // Define the hook, we'll check on the first run if it's really needed.\r\n        return {\r\n            get: function() {\r\n                if ( conditionFn() ) {\r\n\r\n                    // Hook not needed (or it's not possible to use it due\r\n                    // to missing dependency), remove it.\r\n                    delete this.get;\r\n                    return;\r\n                }\r\n\r\n                // Hook needed; redefine it so that the support test is not executed again.\r\n                return ( this.get = hookFn ).apply( this, arguments );\r\n            }\r\n        };\r\n    }\r\n\r\n\r\n    var cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\r\n        emptyStyle = document.createElement( \"div\" ).style,\r\n        vendorProps = {};\r\n\r\n// Return a vendor-prefixed property or undefined\r\n    function vendorPropName( name ) {\r\n\r\n        // Check for vendor prefixed names\r\n        var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\r\n            i = cssPrefixes.length;\r\n\r\n        while ( i-- ) {\r\n            name = cssPrefixes[ i ] + capName;\r\n            if ( name in emptyStyle ) {\r\n                return name;\r\n            }\r\n        }\r\n    }\r\n\r\n// Return a potentially-mapped jQuery.cssProps or vendor prefixed property\r\n    function finalPropName( name ) {\r\n        var final = jQuery.cssProps[ name ] || vendorProps[ name ];\r\n\r\n        if ( final ) {\r\n            return final;\r\n        }\r\n        if ( name in emptyStyle ) {\r\n            return name;\r\n        }\r\n        return vendorProps[ name ] = vendorPropName( name ) || name;\r\n    }\r\n\r\n\r\n    var\r\n\r\n        // Swappable if display is none or starts with table\r\n        // except \"table\", \"table-cell\", or \"table-caption\"\r\n        // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\r\n        rdisplayswap = /^(none|table(?!-c[ea]).+)/,\r\n        rcustomProp = /^--/,\r\n        cssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\r\n        cssNormalTransform = {\r\n            letterSpacing: \"0\",\r\n            fontWeight: \"400\"\r\n        };\r\n\r\n    function setPositiveNumber( _elem, value, subtract ) {\r\n\r\n        // Any relative (+/-) values have already been\r\n        // normalized at this point\r\n        var matches = rcssNum.exec( value );\r\n        return matches ?\r\n\r\n            // Guard against undefined \"subtract\", e.g., when used as in cssHooks\r\n            Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\r\n            value;\r\n    }\r\n\r\n    function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\r\n        var i = dimension === \"width\" ? 1 : 0,\r\n            extra = 0,\r\n            delta = 0;\r\n\r\n        // Adjustment may not be necessary\r\n        if ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\r\n            return 0;\r\n        }\r\n\r\n        for ( ; i < 4; i += 2 ) {\r\n\r\n            // Both box models exclude margin\r\n            if ( box === \"margin\" ) {\r\n                delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\r\n            }\r\n\r\n            // If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\r\n            if ( !isBorderBox ) {\r\n\r\n                // Add padding\r\n                delta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\r\n\r\n                // For \"border\" or \"margin\", add border\r\n                if ( box !== \"padding\" ) {\r\n                    delta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\r\n\r\n                    // But still keep track of it otherwise\r\n                } else {\r\n                    extra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\r\n                }\r\n\r\n                // If we get here with a border-box (content + padding + border), we're seeking \"content\" or\r\n                // \"padding\" or \"margin\"\r\n            } else {\r\n\r\n                // For \"content\", subtract padding\r\n                if ( box === \"content\" ) {\r\n                    delta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\r\n                }\r\n\r\n                // For \"content\" or \"padding\", subtract border\r\n                if ( box !== \"margin\" ) {\r\n                    delta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\r\n                }\r\n            }\r\n        }\r\n\r\n        // Account for positive content-box scroll gutter when requested by providing computedVal\r\n        if ( !isBorderBox && computedVal >= 0 ) {\r\n\r\n            // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\r\n            // Assuming integer scroll gutter, subtract the rest and round down\r\n            delta += Math.max( 0, Math.ceil(\r\n                elem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\r\n                computedVal -\r\n                delta -\r\n                extra -\r\n                0.5\r\n\r\n                // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\r\n                // Use an explicit zero to avoid NaN (gh-3964)\r\n            ) ) || 0;\r\n        }\r\n\r\n        return delta;\r\n    }\r\n\r\n    function getWidthOrHeight( elem, dimension, extra ) {\r\n\r\n        // Start with computed style\r\n        var styles = getStyles( elem ),\r\n\r\n            // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\r\n            // Fake content-box until we know it's needed to know the true value.\r\n            boxSizingNeeded = !support.boxSizingReliable() || extra,\r\n            isBorderBox = boxSizingNeeded &&\r\n                jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\r\n            valueIsBorderBox = isBorderBox,\r\n\r\n            val = curCSS( elem, dimension, styles ),\r\n            offsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\r\n\r\n        // Support: Firefox <=54\r\n        // Return a confounding non-pixel value or feign ignorance, as appropriate.\r\n        if ( rnumnonpx.test( val ) ) {\r\n            if ( !extra ) {\r\n                return val;\r\n            }\r\n            val = \"auto\";\r\n        }\r\n\r\n\r\n        // Support: IE 9 - 11 only\r\n        // Use offsetWidth/offsetHeight for when box sizing is unreliable.\r\n        // In those cases, the computed value can be trusted to be border-box.\r\n        if ( ( !support.boxSizingReliable() && isBorderBox ||\r\n\r\n                // Support: IE 10 - 11+, Edge 15 - 18+\r\n                // IE/Edge misreport `getComputedStyle` of table rows with width/height\r\n                // set in CSS while `offset*` properties report correct values.\r\n                // Interestingly, in some cases IE 9 doesn't suffer from this issue.\r\n                !support.reliableTrDimensions() && nodeName( elem, \"tr\" ) ||\r\n\r\n                // Fall back to offsetWidth/offsetHeight when value is \"auto\"\r\n                // This happens for inline elements with no explicit setting (gh-3571)\r\n                val === \"auto\" ||\r\n\r\n                // Support: Android <=4.1 - 4.3 only\r\n                // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\r\n                !parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) &&\r\n\r\n            // Make sure the element is visible & connected\r\n            elem.getClientRects().length ) {\r\n\r\n            isBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\r\n\r\n            // Where available, offsetWidth/offsetHeight approximate border box dimensions.\r\n            // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\r\n            // retrieved value as a content box dimension.\r\n            valueIsBorderBox = offsetProp in elem;\r\n            if ( valueIsBorderBox ) {\r\n                val = elem[ offsetProp ];\r\n            }\r\n        }\r\n\r\n        // Normalize \"\" and auto\r\n        val = parseFloat( val ) || 0;\r\n\r\n        // Adjust for the element's box model\r\n        return ( val +\r\n            boxModelAdjustment(\r\n                elem,\r\n                dimension,\r\n                extra || ( isBorderBox ? \"border\" : \"content\" ),\r\n                valueIsBorderBox,\r\n                styles,\r\n\r\n                // Provide the current computed size to request scroll gutter calculation (gh-3589)\r\n                val\r\n            )\r\n        ) + \"px\";\r\n    }\r\n\r\n    jQuery.extend( {\r\n\r\n        // Add in style property hooks for overriding the default\r\n        // behavior of getting and setting a style property\r\n        cssHooks: {\r\n            opacity: {\r\n                get: function( elem, computed ) {\r\n                    if ( computed ) {\r\n\r\n                        // We should always get a number back from opacity\r\n                        var ret = curCSS( elem, \"opacity\" );\r\n                        return ret === \"\" ? \"1\" : ret;\r\n                    }\r\n                }\r\n            }\r\n        },\r\n\r\n        // Don't automatically add \"px\" to these possibly-unitless properties\r\n        cssNumber: {\r\n            \"animationIterationCount\": true,\r\n            \"columnCount\": true,\r\n            \"fillOpacity\": true,\r\n            \"flexGrow\": true,\r\n            \"flexShrink\": true,\r\n            \"fontWeight\": true,\r\n            \"gridArea\": true,\r\n            \"gridColumn\": true,\r\n            \"gridColumnEnd\": true,\r\n            \"gridColumnStart\": true,\r\n            \"gridRow\": true,\r\n            \"gridRowEnd\": true,\r\n            \"gridRowStart\": true,\r\n            \"lineHeight\": true,\r\n            \"opacity\": true,\r\n            \"order\": true,\r\n            \"orphans\": true,\r\n            \"widows\": true,\r\n            \"zIndex\": true,\r\n            \"zoom\": true\r\n        },\r\n\r\n        // Add in properties whose names you wish to fix before\r\n        // setting or getting the value\r\n        cssProps: {},\r\n\r\n        // Get and set the style property on a DOM Node\r\n        style: function( elem, name, value, extra ) {\r\n\r\n            // Don't set styles on text and comment nodes\r\n            if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\r\n                return;\r\n            }\r\n\r\n            // Make sure that we're working with the right name\r\n            var ret, type, hooks,\r\n                origName = camelCase( name ),\r\n                isCustomProp = rcustomProp.test( name ),\r\n                style = elem.style;\r\n\r\n            // Make sure that we're working with the right name. We don't\r\n            // want to query the value if it is a CSS custom property\r\n            // since they are user-defined.\r\n            if ( !isCustomProp ) {\r\n                name = finalPropName( origName );\r\n            }\r\n\r\n            // Gets hook for the prefixed version, then unprefixed version\r\n            hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\r\n\r\n            // Check if we're setting a value\r\n            if ( value !== undefined ) {\r\n                type = typeof value;\r\n\r\n                // Convert \"+=\" or \"-=\" to relative numbers (#7345)\r\n                if ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\r\n                    value = adjustCSS( elem, name, ret );\r\n\r\n                    // Fixes bug #9237\r\n                    type = \"number\";\r\n                }\r\n\r\n                // Make sure that null and NaN values aren't set (#7116)\r\n                if ( value == null || value !== value ) {\r\n                    return;\r\n                }\r\n\r\n                // If a number was passed in, add the unit (except for certain CSS properties)\r\n                // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\r\n                // \"px\" to a few hardcoded values.\r\n                if ( type === \"number\" && !isCustomProp ) {\r\n                    value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\r\n                }\r\n\r\n                // background-* props affect original clone's values\r\n                if ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\r\n                    style[ name ] = \"inherit\";\r\n                }\r\n\r\n                // If a hook was provided, use that value, otherwise just set the specified value\r\n                if ( !hooks || !( \"set\" in hooks ) ||\r\n                    ( value = hooks.set( elem, value, extra ) ) !== undefined ) {\r\n\r\n                    if ( isCustomProp ) {\r\n                        style.setProperty( name, value );\r\n                    } else {\r\n                        style[ name ] = value;\r\n                    }\r\n                }\r\n\r\n            } else {\r\n\r\n                // If a hook was provided get the non-computed value from there\r\n                if ( hooks && \"get\" in hooks &&\r\n                    ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\r\n\r\n                    return ret;\r\n                }\r\n\r\n                // Otherwise just get the value from the style object\r\n                return style[ name ];\r\n            }\r\n        },\r\n\r\n        css: function( elem, name, extra, styles ) {\r\n            var val, num, hooks,\r\n                origName = camelCase( name ),\r\n                isCustomProp = rcustomProp.test( name );\r\n\r\n            // Make sure that we're working with the right name. We don't\r\n            // want to modify the value if it is a CSS custom property\r\n            // since they are user-defined.\r\n            if ( !isCustomProp ) {\r\n                name = finalPropName( origName );\r\n            }\r\n\r\n            // Try prefixed name followed by the unprefixed name\r\n            hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\r\n\r\n            // If a hook was provided get the computed value from there\r\n            if ( hooks && \"get\" in hooks ) {\r\n                val = hooks.get( elem, true, extra );\r\n            }\r\n\r\n            // Otherwise, if a way to get the computed value exists, use that\r\n            if ( val === undefined ) {\r\n                val = curCSS( elem, name, styles );\r\n            }\r\n\r\n            // Convert \"normal\" to computed value\r\n            if ( val === \"normal\" && name in cssNormalTransform ) {\r\n                val = cssNormalTransform[ name ];\r\n            }\r\n\r\n            // Make numeric if forced or a qualifier was provided and val looks numeric\r\n            if ( extra === \"\" || extra ) {\r\n                num = parseFloat( val );\r\n                return extra === true || isFinite( num ) ? num || 0 : val;\r\n            }\r\n\r\n            return val;\r\n        }\r\n    } );\r\n\r\n    jQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\r\n        jQuery.cssHooks[ dimension ] = {\r\n            get: function( elem, computed, extra ) {\r\n                if ( computed ) {\r\n\r\n                    // Certain elements can have dimension info if we invisibly show them\r\n                    // but it must have a current display style that would benefit\r\n                    return rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\r\n\r\n                    // Support: Safari 8+\r\n                    // Table columns in Safari have non-zero offsetWidth & zero\r\n                    // getBoundingClientRect().width unless display is changed.\r\n                    // Support: IE <=11 only\r\n                    // Running getBoundingClientRect on a disconnected node\r\n                    // in IE throws an error.\r\n                    ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\r\n                        swap( elem, cssShow, function() {\r\n                            return getWidthOrHeight( elem, dimension, extra );\r\n                        } ) :\r\n                        getWidthOrHeight( elem, dimension, extra );\r\n                }\r\n            },\r\n\r\n            set: function( elem, value, extra ) {\r\n                var matches,\r\n                    styles = getStyles( elem ),\r\n\r\n                    // Only read styles.position if the test has a chance to fail\r\n                    // to avoid forcing a reflow.\r\n                    scrollboxSizeBuggy = !support.scrollboxSize() &&\r\n                        styles.position === \"absolute\",\r\n\r\n                    // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\r\n                    boxSizingNeeded = scrollboxSizeBuggy || extra,\r\n                    isBorderBox = boxSizingNeeded &&\r\n                        jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\r\n                    subtract = extra ?\r\n                        boxModelAdjustment(\r\n                            elem,\r\n                            dimension,\r\n                            extra,\r\n                            isBorderBox,\r\n                            styles\r\n                        ) :\r\n                        0;\r\n\r\n                // Account for unreliable border-box dimensions by comparing offset* to computed and\r\n                // faking a content-box to get border and padding (gh-3699)\r\n                if ( isBorderBox && scrollboxSizeBuggy ) {\r\n                    subtract -= Math.ceil(\r\n                        elem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\r\n                        parseFloat( styles[ dimension ] ) -\r\n                        boxModelAdjustment( elem, dimension, \"border\", false, styles ) -\r\n                        0.5\r\n                    );\r\n                }\r\n\r\n                // Convert to pixels if value adjustment is needed\r\n                if ( subtract && ( matches = rcssNum.exec( value ) ) &&\r\n                    ( matches[ 3 ] || \"px\" ) !== \"px\" ) {\r\n\r\n                    elem.style[ dimension ] = value;\r\n                    value = jQuery.css( elem, dimension );\r\n                }\r\n\r\n                return setPositiveNumber( elem, value, subtract );\r\n            }\r\n        };\r\n    } );\r\n\r\n    jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\r\n        function( elem, computed ) {\r\n            if ( computed ) {\r\n                return ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\r\n                    elem.getBoundingClientRect().left -\r\n                    swap( elem, { marginLeft: 0 }, function() {\r\n                        return elem.getBoundingClientRect().left;\r\n                    } )\r\n                ) + \"px\";\r\n            }\r\n        }\r\n    );\r\n\r\n// These hooks are used by animate to expand properties\r\n    jQuery.each( {\r\n        margin: \"\",\r\n        padding: \"\",\r\n        border: \"Width\"\r\n    }, function( prefix, suffix ) {\r\n        jQuery.cssHooks[ prefix + suffix ] = {\r\n            expand: function( value ) {\r\n                var i = 0,\r\n                    expanded = {},\r\n\r\n                    // Assumes a single number if not a string\r\n                    parts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\r\n\r\n                for ( ; i < 4; i++ ) {\r\n                    expanded[ prefix + cssExpand[ i ] + suffix ] =\r\n                        parts[ i ] || parts[ i - 2 ] || parts[ 0 ];\r\n                }\r\n\r\n                return expanded;\r\n            }\r\n        };\r\n\r\n        if ( prefix !== \"margin\" ) {\r\n            jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\r\n        }\r\n    } );\r\n\r\n    jQuery.fn.extend( {\r\n        css: function( name, value ) {\r\n            return access( this, function( elem, name, value ) {\r\n                var styles, len,\r\n                    map = {},\r\n                    i = 0;\r\n\r\n                if ( Array.isArray( name ) ) {\r\n                    styles = getStyles( elem );\r\n                    len = name.length;\r\n\r\n                    for ( ; i < len; i++ ) {\r\n                        map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\r\n                    }\r\n\r\n                    return map;\r\n                }\r\n\r\n                return value !== undefined ?\r\n                    jQuery.style( elem, name, value ) :\r\n                    jQuery.css( elem, name );\r\n            }, name, value, arguments.length > 1 );\r\n        }\r\n    } );\r\n\r\n\r\n    function Tween( elem, options, prop, end, easing ) {\r\n        return new Tween.prototype.init( elem, options, prop, end, easing );\r\n    }\r\n    jQuery.Tween = Tween;\r\n\r\n    Tween.prototype = {\r\n        constructor: Tween,\r\n        init: function( elem, options, prop, end, easing, unit ) {\r\n            this.elem = elem;\r\n            this.prop = prop;\r\n            this.easing = easing || jQuery.easing._default;\r\n            this.options = options;\r\n            this.start = this.now = this.cur();\r\n            this.end = end;\r\n            this.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\r\n        },\r\n        cur: function() {\r\n            var hooks = Tween.propHooks[ this.prop ];\r\n\r\n            return hooks && hooks.get ?\r\n                hooks.get( this ) :\r\n                Tween.propHooks._default.get( this );\r\n        },\r\n        run: function( percent ) {\r\n            var eased,\r\n                hooks = Tween.propHooks[ this.prop ];\r\n\r\n            if ( this.options.duration ) {\r\n                this.pos = eased = jQuery.easing[ this.easing ](\r\n                    percent, this.options.duration * percent, 0, 1, this.options.duration\r\n                );\r\n            } else {\r\n                this.pos = eased = percent;\r\n            }\r\n            this.now = ( this.end - this.start ) * eased + this.start;\r\n\r\n            if ( this.options.step ) {\r\n                this.options.step.call( this.elem, this.now, this );\r\n            }\r\n\r\n            if ( hooks && hooks.set ) {\r\n                hooks.set( this );\r\n            } else {\r\n                Tween.propHooks._default.set( this );\r\n            }\r\n            return this;\r\n        }\r\n    };\r\n\r\n    Tween.prototype.init.prototype = Tween.prototype;\r\n\r\n    Tween.propHooks = {\r\n        _default: {\r\n            get: function( tween ) {\r\n                var result;\r\n\r\n                // Use a property on the element directly when it is not a DOM element,\r\n                // or when there is no matching style property that exists.\r\n                if ( tween.elem.nodeType !== 1 ||\r\n                    tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\r\n                    return tween.elem[ tween.prop ];\r\n                }\r\n\r\n                // Passing an empty string as a 3rd parameter to .css will automatically\r\n                // attempt a parseFloat and fallback to a string if the parse fails.\r\n                // Simple values such as \"10px\" are parsed to Float;\r\n                // complex values such as \"rotate(1rad)\" are returned as-is.\r\n                result = jQuery.css( tween.elem, tween.prop, \"\" );\r\n\r\n                // Empty strings, null, undefined and \"auto\" are converted to 0.\r\n                return !result || result === \"auto\" ? 0 : result;\r\n            },\r\n            set: function( tween ) {\r\n\r\n                // Use step hook for back compat.\r\n                // Use cssHook if its there.\r\n                // Use .style if available and use plain properties where available.\r\n                if ( jQuery.fx.step[ tween.prop ] ) {\r\n                    jQuery.fx.step[ tween.prop ]( tween );\r\n                } else if ( tween.elem.nodeType === 1 && (\r\n                    jQuery.cssHooks[ tween.prop ] ||\r\n                    tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\r\n                    jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\r\n                } else {\r\n                    tween.elem[ tween.prop ] = tween.now;\r\n                }\r\n            }\r\n        }\r\n    };\r\n\r\n// Support: IE <=9 only\r\n// Panic based approach to setting things on disconnected nodes\r\n    Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\r\n        set: function( tween ) {\r\n            if ( tween.elem.nodeType && tween.elem.parentNode ) {\r\n                tween.elem[ tween.prop ] = tween.now;\r\n            }\r\n        }\r\n    };\r\n\r\n    jQuery.easing = {\r\n        linear: function( p ) {\r\n            return p;\r\n        },\r\n        swing: function( p ) {\r\n            return 0.5 - Math.cos( p * Math.PI ) / 2;\r\n        },\r\n        _default: \"swing\"\r\n    };\r\n\r\n    jQuery.fx = Tween.prototype.init;\r\n\r\n// Back compat <1.8 extension point\r\n    jQuery.fx.step = {};\r\n\r\n\r\n\r\n\r\n    var\r\n        fxNow, inProgress,\r\n        rfxtypes = /^(?:toggle|show|hide)$/,\r\n        rrun = /queueHooks$/;\r\n\r\n    function schedule() {\r\n        if ( inProgress ) {\r\n            if ( document.hidden === false && window.requestAnimationFrame ) {\r\n                window.requestAnimationFrame( schedule );\r\n            } else {\r\n                window.setTimeout( schedule, jQuery.fx.interval );\r\n            }\r\n\r\n            jQuery.fx.tick();\r\n        }\r\n    }\r\n\r\n// Animations created synchronously will run synchronously\r\n    function createFxNow() {\r\n        window.setTimeout( function() {\r\n            fxNow = undefined;\r\n        } );\r\n        return ( fxNow = Date.now() );\r\n    }\r\n\r\n// Generate parameters to create a standard animation\r\n    function genFx( type, includeWidth ) {\r\n        var which,\r\n            i = 0,\r\n            attrs = { height: type };\r\n\r\n        // If we include width, step value is 1 to do all cssExpand values,\r\n        // otherwise step value is 2 to skip over Left and Right\r\n        includeWidth = includeWidth ? 1 : 0;\r\n        for ( ; i < 4; i += 2 - includeWidth ) {\r\n            which = cssExpand[ i ];\r\n            attrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\r\n        }\r\n\r\n        if ( includeWidth ) {\r\n            attrs.opacity = attrs.width = type;\r\n        }\r\n\r\n        return attrs;\r\n    }\r\n\r\n    function createTween( value, prop, animation ) {\r\n        var tween,\r\n            collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\r\n            index = 0,\r\n            length = collection.length;\r\n        for ( ; index < length; index++ ) {\r\n            if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\r\n\r\n                // We're done with this property\r\n                return tween;\r\n            }\r\n        }\r\n    }\r\n\r\n    function defaultPrefilter( elem, props, opts ) {\r\n        var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\r\n            isBox = \"width\" in props || \"height\" in props,\r\n            anim = this,\r\n            orig = {},\r\n            style = elem.style,\r\n            hidden = elem.nodeType && isHiddenWithinTree( elem ),\r\n            dataShow = dataPriv.get( elem, \"fxshow\" );\r\n\r\n        // Queue-skipping animations hijack the fx hooks\r\n        if ( !opts.queue ) {\r\n            hooks = jQuery._queueHooks( elem, \"fx\" );\r\n            if ( hooks.unqueued == null ) {\r\n                hooks.unqueued = 0;\r\n                oldfire = hooks.empty.fire;\r\n                hooks.empty.fire = function() {\r\n                    if ( !hooks.unqueued ) {\r\n                        oldfire();\r\n                    }\r\n                };\r\n            }\r\n            hooks.unqueued++;\r\n\r\n            anim.always( function() {\r\n\r\n                // Ensure the complete handler is called before this completes\r\n                anim.always( function() {\r\n                    hooks.unqueued--;\r\n                    if ( !jQuery.queue( elem, \"fx\" ).length ) {\r\n                        hooks.empty.fire();\r\n                    }\r\n                } );\r\n            } );\r\n        }\r\n\r\n        // Detect show/hide animations\r\n        for ( prop in props ) {\r\n            value = props[ prop ];\r\n            if ( rfxtypes.test( value ) ) {\r\n                delete props[ prop ];\r\n                toggle = toggle || value === \"toggle\";\r\n                if ( value === ( hidden ? \"hide\" : \"show\" ) ) {\r\n\r\n                    // Pretend to be hidden if this is a \"show\" and\r\n                    // there is still data from a stopped show/hide\r\n                    if ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\r\n                        hidden = true;\r\n\r\n                        // Ignore all other no-op show/hide data\r\n                    } else {\r\n                        continue;\r\n                    }\r\n                }\r\n                orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\r\n            }\r\n        }\r\n\r\n        // Bail out if this is a no-op like .hide().hide()\r\n        propTween = !jQuery.isEmptyObject( props );\r\n        if ( !propTween && jQuery.isEmptyObject( orig ) ) {\r\n            return;\r\n        }\r\n\r\n        // Restrict \"overflow\" and \"display\" styles during box animations\r\n        if ( isBox && elem.nodeType === 1 ) {\r\n\r\n            // Support: IE <=9 - 11, Edge 12 - 15\r\n            // Record all 3 overflow attributes because IE does not infer the shorthand\r\n            // from identically-valued overflowX and overflowY and Edge just mirrors\r\n            // the overflowX value there.\r\n            opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\r\n\r\n            // Identify a display type, preferring old show/hide data over the CSS cascade\r\n            restoreDisplay = dataShow && dataShow.display;\r\n            if ( restoreDisplay == null ) {\r\n                restoreDisplay = dataPriv.get( elem, \"display\" );\r\n            }\r\n            display = jQuery.css( elem, \"display\" );\r\n            if ( display === \"none\" ) {\r\n                if ( restoreDisplay ) {\r\n                    display = restoreDisplay;\r\n                } else {\r\n\r\n                    // Get nonempty value(s) by temporarily forcing visibility\r\n                    showHide( [ elem ], true );\r\n                    restoreDisplay = elem.style.display || restoreDisplay;\r\n                    display = jQuery.css( elem, \"display\" );\r\n                    showHide( [ elem ] );\r\n                }\r\n            }\r\n\r\n            // Animate inline elements as inline-block\r\n            if ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\r\n                if ( jQuery.css( elem, \"float\" ) === \"none\" ) {\r\n\r\n                    // Restore the original display value at the end of pure show/hide animations\r\n                    if ( !propTween ) {\r\n                        anim.done( function() {\r\n                            style.display = restoreDisplay;\r\n                        } );\r\n                        if ( restoreDisplay == null ) {\r\n                            display = style.display;\r\n                            restoreDisplay = display === \"none\" ? \"\" : display;\r\n                        }\r\n                    }\r\n                    style.display = \"inline-block\";\r\n                }\r\n            }\r\n        }\r\n\r\n        if ( opts.overflow ) {\r\n            style.overflow = \"hidden\";\r\n            anim.always( function() {\r\n                style.overflow = opts.overflow[ 0 ];\r\n                style.overflowX = opts.overflow[ 1 ];\r\n                style.overflowY = opts.overflow[ 2 ];\r\n            } );\r\n        }\r\n\r\n        // Implement show/hide animations\r\n        propTween = false;\r\n        for ( prop in orig ) {\r\n\r\n            // General show/hide setup for this element animation\r\n            if ( !propTween ) {\r\n                if ( dataShow ) {\r\n                    if ( \"hidden\" in dataShow ) {\r\n                        hidden = dataShow.hidden;\r\n                    }\r\n                } else {\r\n                    dataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\r\n                }\r\n\r\n                // Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\r\n                if ( toggle ) {\r\n                    dataShow.hidden = !hidden;\r\n                }\r\n\r\n                // Show elements before animating them\r\n                if ( hidden ) {\r\n                    showHide( [ elem ], true );\r\n                }\r\n\r\n                /* eslint-disable no-loop-func */\r\n\r\n                anim.done( function() {\r\n\r\n                    /* eslint-enable no-loop-func */\r\n\r\n                    // The final step of a \"hide\" animation is actually hiding the element\r\n                    if ( !hidden ) {\r\n                        showHide( [ elem ] );\r\n                    }\r\n                    dataPriv.remove( elem, \"fxshow\" );\r\n                    for ( prop in orig ) {\r\n                        jQuery.style( elem, prop, orig[ prop ] );\r\n                    }\r\n                } );\r\n            }\r\n\r\n            // Per-property setup\r\n            propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\r\n            if ( !( prop in dataShow ) ) {\r\n                dataShow[ prop ] = propTween.start;\r\n                if ( hidden ) {\r\n                    propTween.end = propTween.start;\r\n                    propTween.start = 0;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    function propFilter( props, specialEasing ) {\r\n        var index, name, easing, value, hooks;\r\n\r\n        // camelCase, specialEasing and expand cssHook pass\r\n        for ( index in props ) {\r\n            name = camelCase( index );\r\n            easing = specialEasing[ name ];\r\n            value = props[ index ];\r\n            if ( Array.isArray( value ) ) {\r\n                easing = value[ 1 ];\r\n                value = props[ index ] = value[ 0 ];\r\n            }\r\n\r\n            if ( index !== name ) {\r\n                props[ name ] = value;\r\n                delete props[ index ];\r\n            }\r\n\r\n            hooks = jQuery.cssHooks[ name ];\r\n            if ( hooks && \"expand\" in hooks ) {\r\n                value = hooks.expand( value );\r\n                delete props[ name ];\r\n\r\n                // Not quite $.extend, this won't overwrite existing keys.\r\n                // Reusing 'index' because we have the correct \"name\"\r\n                for ( index in value ) {\r\n                    if ( !( index in props ) ) {\r\n                        props[ index ] = value[ index ];\r\n                        specialEasing[ index ] = easing;\r\n                    }\r\n                }\r\n            } else {\r\n                specialEasing[ name ] = easing;\r\n            }\r\n        }\r\n    }\r\n\r\n    function Animation( elem, properties, options ) {\r\n        var result,\r\n            stopped,\r\n            index = 0,\r\n            length = Animation.prefilters.length,\r\n            deferred = jQuery.Deferred().always( function() {\r\n\r\n                // Don't match elem in the :animated selector\r\n                delete tick.elem;\r\n            } ),\r\n            tick = function() {\r\n                if ( stopped ) {\r\n                    return false;\r\n                }\r\n                var currentTime = fxNow || createFxNow(),\r\n                    remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\r\n\r\n                    // Support: Android 2.3 only\r\n                    // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\r\n                    temp = remaining / animation.duration || 0,\r\n                    percent = 1 - temp,\r\n                    index = 0,\r\n                    length = animation.tweens.length;\r\n\r\n                for ( ; index < length; index++ ) {\r\n                    animation.tweens[ index ].run( percent );\r\n                }\r\n\r\n                deferred.notifyWith( elem, [ animation, percent, remaining ] );\r\n\r\n                // If there's more to do, yield\r\n                if ( percent < 1 && length ) {\r\n                    return remaining;\r\n                }\r\n\r\n                // If this was an empty animation, synthesize a final progress notification\r\n                if ( !length ) {\r\n                    deferred.notifyWith( elem, [ animation, 1, 0 ] );\r\n                }\r\n\r\n                // Resolve the animation and report its conclusion\r\n                deferred.resolveWith( elem, [ animation ] );\r\n                return false;\r\n            },\r\n            animation = deferred.promise( {\r\n                elem: elem,\r\n                props: jQuery.extend( {}, properties ),\r\n                opts: jQuery.extend( true, {\r\n                    specialEasing: {},\r\n                    easing: jQuery.easing._default\r\n                }, options ),\r\n                originalProperties: properties,\r\n                originalOptions: options,\r\n                startTime: fxNow || createFxNow(),\r\n                duration: options.duration,\r\n                tweens: [],\r\n                createTween: function( prop, end ) {\r\n                    var tween = jQuery.Tween( elem, animation.opts, prop, end,\r\n                        animation.opts.specialEasing[ prop ] || animation.opts.easing );\r\n                    animation.tweens.push( tween );\r\n                    return tween;\r\n                },\r\n                stop: function( gotoEnd ) {\r\n                    var index = 0,\r\n\r\n                        // If we are going to the end, we want to run all the tweens\r\n                        // otherwise we skip this part\r\n                        length = gotoEnd ? animation.tweens.length : 0;\r\n                    if ( stopped ) {\r\n                        return this;\r\n                    }\r\n                    stopped = true;\r\n                    for ( ; index < length; index++ ) {\r\n                        animation.tweens[ index ].run( 1 );\r\n                    }\r\n\r\n                    // Resolve when we played the last frame; otherwise, reject\r\n                    if ( gotoEnd ) {\r\n                        deferred.notifyWith( elem, [ animation, 1, 0 ] );\r\n                        deferred.resolveWith( elem, [ animation, gotoEnd ] );\r\n                    } else {\r\n                        deferred.rejectWith( elem, [ animation, gotoEnd ] );\r\n                    }\r\n                    return this;\r\n                }\r\n            } ),\r\n            props = animation.props;\r\n\r\n        propFilter( props, animation.opts.specialEasing );\r\n\r\n        for ( ; index < length; index++ ) {\r\n            result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\r\n            if ( result ) {\r\n                if ( isFunction( result.stop ) ) {\r\n                    jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\r\n                        result.stop.bind( result );\r\n                }\r\n                return result;\r\n            }\r\n        }\r\n\r\n        jQuery.map( props, createTween, animation );\r\n\r\n        if ( isFunction( animation.opts.start ) ) {\r\n            animation.opts.start.call( elem, animation );\r\n        }\r\n\r\n        // Attach callbacks from options\r\n        animation\r\n            .progress( animation.opts.progress )\r\n            .done( animation.opts.done, animation.opts.complete )\r\n            .fail( animation.opts.fail )\r\n            .always( animation.opts.always );\r\n\r\n        jQuery.fx.timer(\r\n            jQuery.extend( tick, {\r\n                elem: elem,\r\n                anim: animation,\r\n                queue: animation.opts.queue\r\n            } )\r\n        );\r\n\r\n        return animation;\r\n    }\r\n\r\n    jQuery.Animation = jQuery.extend( Animation, {\r\n\r\n        tweeners: {\r\n            \"*\": [ function( prop, value ) {\r\n                var tween = this.createTween( prop, value );\r\n                adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\r\n                return tween;\r\n            } ]\r\n        },\r\n\r\n        tweener: function( props, callback ) {\r\n            if ( isFunction( props ) ) {\r\n                callback = props;\r\n                props = [ \"*\" ];\r\n            } else {\r\n                props = props.match( rnothtmlwhite );\r\n            }\r\n\r\n            var prop,\r\n                index = 0,\r\n                length = props.length;\r\n\r\n            for ( ; index < length; index++ ) {\r\n                prop = props[ index ];\r\n                Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\r\n                Animation.tweeners[ prop ].unshift( callback );\r\n            }\r\n        },\r\n\r\n        prefilters: [ defaultPrefilter ],\r\n\r\n        prefilter: function( callback, prepend ) {\r\n            if ( prepend ) {\r\n                Animation.prefilters.unshift( callback );\r\n            } else {\r\n                Animation.prefilters.push( callback );\r\n            }\r\n        }\r\n    } );\r\n\r\n    jQuery.speed = function( speed, easing, fn ) {\r\n        var opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\r\n            complete: fn || !fn && easing ||\r\n                isFunction( speed ) && speed,\r\n            duration: speed,\r\n            easing: fn && easing || easing && !isFunction( easing ) && easing\r\n        };\r\n\r\n        // Go to the end state if fx are off\r\n        if ( jQuery.fx.off ) {\r\n            opt.duration = 0;\r\n\r\n        } else {\r\n            if ( typeof opt.duration !== \"number\" ) {\r\n                if ( opt.duration in jQuery.fx.speeds ) {\r\n                    opt.duration = jQuery.fx.speeds[ opt.duration ];\r\n\r\n                } else {\r\n                    opt.duration = jQuery.fx.speeds._default;\r\n                }\r\n            }\r\n        }\r\n\r\n        // Normalize opt.queue - true/undefined/null -> \"fx\"\r\n        if ( opt.queue == null || opt.queue === true ) {\r\n            opt.queue = \"fx\";\r\n        }\r\n\r\n        // Queueing\r\n        opt.old = opt.complete;\r\n\r\n        opt.complete = function() {\r\n            if ( isFunction( opt.old ) ) {\r\n                opt.old.call( this );\r\n            }\r\n\r\n            if ( opt.queue ) {\r\n                jQuery.dequeue( this, opt.queue );\r\n            }\r\n        };\r\n\r\n        return opt;\r\n    };\r\n\r\n    jQuery.fn.extend( {\r\n        fadeTo: function( speed, to, easing, callback ) {\r\n\r\n            // Show any hidden elements after setting opacity to 0\r\n            return this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\r\n\r\n                // Animate to the value specified\r\n                .end().animate( { opacity: to }, speed, easing, callback );\r\n        },\r\n        animate: function( prop, speed, easing, callback ) {\r\n            var empty = jQuery.isEmptyObject( prop ),\r\n                optall = jQuery.speed( speed, easing, callback ),\r\n                doAnimation = function() {\r\n\r\n                    // Operate on a copy of prop so per-property easing won't be lost\r\n                    var anim = Animation( this, jQuery.extend( {}, prop ), optall );\r\n\r\n                    // Empty animations, or finishing resolves immediately\r\n                    if ( empty || dataPriv.get( this, \"finish\" ) ) {\r\n                        anim.stop( true );\r\n                    }\r\n                };\r\n\r\n            doAnimation.finish = doAnimation;\r\n\r\n            return empty || optall.queue === false ?\r\n                this.each( doAnimation ) :\r\n                this.queue( optall.queue, doAnimation );\r\n        },\r\n        stop: function( type, clearQueue, gotoEnd ) {\r\n            var stopQueue = function( hooks ) {\r\n                var stop = hooks.stop;\r\n                delete hooks.stop;\r\n                stop( gotoEnd );\r\n            };\r\n\r\n            if ( typeof type !== \"string\" ) {\r\n                gotoEnd = clearQueue;\r\n                clearQueue = type;\r\n                type = undefined;\r\n            }\r\n            if ( clearQueue ) {\r\n                this.queue( type || \"fx\", [] );\r\n            }\r\n\r\n            return this.each( function() {\r\n                var dequeue = true,\r\n                    index = type != null && type + \"queueHooks\",\r\n                    timers = jQuery.timers,\r\n                    data = dataPriv.get( this );\r\n\r\n                if ( index ) {\r\n                    if ( data[ index ] && data[ index ].stop ) {\r\n                        stopQueue( data[ index ] );\r\n                    }\r\n                } else {\r\n                    for ( index in data ) {\r\n                        if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\r\n                            stopQueue( data[ index ] );\r\n                        }\r\n                    }\r\n                }\r\n\r\n                for ( index = timers.length; index--; ) {\r\n                    if ( timers[ index ].elem === this &&\r\n                        ( type == null || timers[ index ].queue === type ) ) {\r\n\r\n                        timers[ index ].anim.stop( gotoEnd );\r\n                        dequeue = false;\r\n                        timers.splice( index, 1 );\r\n                    }\r\n                }\r\n\r\n                // Start the next in the queue if the last step wasn't forced.\r\n                // Timers currently will call their complete callbacks, which\r\n                // will dequeue but only if they were gotoEnd.\r\n                if ( dequeue || !gotoEnd ) {\r\n                    jQuery.dequeue( this, type );\r\n                }\r\n            } );\r\n        },\r\n        finish: function( type ) {\r\n            if ( type !== false ) {\r\n                type = type || \"fx\";\r\n            }\r\n            return this.each( function() {\r\n                var index,\r\n                    data = dataPriv.get( this ),\r\n                    queue = data[ type + \"queue\" ],\r\n                    hooks = data[ type + \"queueHooks\" ],\r\n                    timers = jQuery.timers,\r\n                    length = queue ? queue.length : 0;\r\n\r\n                // Enable finishing flag on private data\r\n                data.finish = true;\r\n\r\n                // Empty the queue first\r\n                jQuery.queue( this, type, [] );\r\n\r\n                if ( hooks && hooks.stop ) {\r\n                    hooks.stop.call( this, true );\r\n                }\r\n\r\n                // Look for any active animations, and finish them\r\n                for ( index = timers.length; index--; ) {\r\n                    if ( timers[ index ].elem === this && timers[ index ].queue === type ) {\r\n                        timers[ index ].anim.stop( true );\r\n                        timers.splice( index, 1 );\r\n                    }\r\n                }\r\n\r\n                // Look for any animations in the old queue and finish them\r\n                for ( index = 0; index < length; index++ ) {\r\n                    if ( queue[ index ] && queue[ index ].finish ) {\r\n                        queue[ index ].finish.call( this );\r\n                    }\r\n                }\r\n\r\n                // Turn off finishing flag\r\n                delete data.finish;\r\n            } );\r\n        }\r\n    } );\r\n\r\n    jQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\r\n        var cssFn = jQuery.fn[ name ];\r\n        jQuery.fn[ name ] = function( speed, easing, callback ) {\r\n            return speed == null || typeof speed === \"boolean\" ?\r\n                cssFn.apply( this, arguments ) :\r\n                this.animate( genFx( name, true ), speed, easing, callback );\r\n        };\r\n    } );\r\n\r\n// Generate shortcuts for custom animations\r\n    jQuery.each( {\r\n        slideDown: genFx( \"show\" ),\r\n        slideUp: genFx( \"hide\" ),\r\n        slideToggle: genFx( \"toggle\" ),\r\n        fadeIn: { opacity: \"show\" },\r\n        fadeOut: { opacity: \"hide\" },\r\n        fadeToggle: { opacity: \"toggle\" }\r\n    }, function( name, props ) {\r\n        jQuery.fn[ name ] = function( speed, easing, callback ) {\r\n            return this.animate( props, speed, easing, callback );\r\n        };\r\n    } );\r\n\r\n    jQuery.timers = [];\r\n    jQuery.fx.tick = function() {\r\n        var timer,\r\n            i = 0,\r\n            timers = jQuery.timers;\r\n\r\n        fxNow = Date.now();\r\n\r\n        for ( ; i < timers.length; i++ ) {\r\n            timer = timers[ i ];\r\n\r\n            // Run the timer and safely remove it when done (allowing for external removal)\r\n            if ( !timer() && timers[ i ] === timer ) {\r\n                timers.splice( i--, 1 );\r\n            }\r\n        }\r\n\r\n        if ( !timers.length ) {\r\n            jQuery.fx.stop();\r\n        }\r\n        fxNow = undefined;\r\n    };\r\n\r\n    jQuery.fx.timer = function( timer ) {\r\n        jQuery.timers.push( timer );\r\n        jQuery.fx.start();\r\n    };\r\n\r\n    jQuery.fx.interval = 13;\r\n    jQuery.fx.start = function() {\r\n        if ( inProgress ) {\r\n            return;\r\n        }\r\n\r\n        inProgress = true;\r\n        schedule();\r\n    };\r\n\r\n    jQuery.fx.stop = function() {\r\n        inProgress = null;\r\n    };\r\n\r\n    jQuery.fx.speeds = {\r\n        slow: 600,\r\n        fast: 200,\r\n\r\n        // Default speed\r\n        _default: 400\r\n    };\r\n\r\n\r\n// Based off of the plugin by Clint Helfers, with permission.\r\n// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\r\n    jQuery.fn.delay = function( time, type ) {\r\n        time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\r\n        type = type || \"fx\";\r\n\r\n        return this.queue( type, function( next, hooks ) {\r\n            var timeout = window.setTimeout( next, time );\r\n            hooks.stop = function() {\r\n                window.clearTimeout( timeout );\r\n            };\r\n        } );\r\n    };\r\n\r\n\r\n    ( function() {\r\n        var input = document.createElement( \"input\" ),\r\n            select = document.createElement( \"select\" ),\r\n            opt = select.appendChild( document.createElement( \"option\" ) );\r\n\r\n        input.type = \"checkbox\";\r\n\r\n        // Support: Android <=4.3 only\r\n        // Default value for a checkbox should be \"on\"\r\n        support.checkOn = input.value !== \"\";\r\n\r\n        // Support: IE <=11 only\r\n        // Must access selectedIndex to make default options select\r\n        support.optSelected = opt.selected;\r\n\r\n        // Support: IE <=11 only\r\n        // An input loses its value after becoming a radio\r\n        input = document.createElement( \"input\" );\r\n        input.value = \"t\";\r\n        input.type = \"radio\";\r\n        support.radioValue = input.value === \"t\";\r\n    } )();\r\n\r\n\r\n    var boolHook,\r\n        attrHandle = jQuery.expr.attrHandle;\r\n\r\n    jQuery.fn.extend( {\r\n        attr: function( name, value ) {\r\n            return access( this, jQuery.attr, name, value, arguments.length > 1 );\r\n        },\r\n\r\n        removeAttr: function( name ) {\r\n            return this.each( function() {\r\n                jQuery.removeAttr( this, name );\r\n            } );\r\n        }\r\n    } );\r\n\r\n    jQuery.extend( {\r\n        attr: function( elem, name, value ) {\r\n            var ret, hooks,\r\n                nType = elem.nodeType;\r\n\r\n            // Don't get/set attributes on text, comment and attribute nodes\r\n            if ( nType === 3 || nType === 8 || nType === 2 ) {\r\n                return;\r\n            }\r\n\r\n            // Fallback to prop when attributes are not supported\r\n            if ( typeof elem.getAttribute === \"undefined\" ) {\r\n                return jQuery.prop( elem, name, value );\r\n            }\r\n\r\n            // Attribute hooks are determined by the lowercase version\r\n            // Grab necessary hook if one is defined\r\n            if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\r\n                hooks = jQuery.attrHooks[ name.toLowerCase() ] ||\r\n                    ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\r\n            }\r\n\r\n            if ( value !== undefined ) {\r\n                if ( value === null ) {\r\n                    jQuery.removeAttr( elem, name );\r\n                    return;\r\n                }\r\n\r\n                if ( hooks && \"set\" in hooks &&\r\n                    ( ret = hooks.set( elem, value, name ) ) !== undefined ) {\r\n                    return ret;\r\n                }\r\n\r\n                elem.setAttribute( name, value + \"\" );\r\n                return value;\r\n            }\r\n\r\n            if ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\r\n                return ret;\r\n            }\r\n\r\n            ret = jQuery.find.attr( elem, name );\r\n\r\n            // Non-existent attributes return null, we normalize to undefined\r\n            return ret == null ? undefined : ret;\r\n        },\r\n\r\n        attrHooks: {\r\n            type: {\r\n                set: function( elem, value ) {\r\n                    if ( !support.radioValue && value === \"radio\" &&\r\n                        nodeName( elem, \"input\" ) ) {\r\n                        var val = elem.value;\r\n                        elem.setAttribute( \"type\", value );\r\n                        if ( val ) {\r\n                            elem.value = val;\r\n                        }\r\n                        return value;\r\n                    }\r\n                }\r\n            }\r\n        },\r\n\r\n        removeAttr: function( elem, value ) {\r\n            var name,\r\n                i = 0,\r\n\r\n                // Attribute names can contain non-HTML whitespace characters\r\n                // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\r\n                attrNames = value && value.match( rnothtmlwhite );\r\n\r\n            if ( attrNames && elem.nodeType === 1 ) {\r\n                while ( ( name = attrNames[ i++ ] ) ) {\r\n                    elem.removeAttribute( name );\r\n                }\r\n            }\r\n        }\r\n    } );\r\n\r\n// Hooks for boolean attributes\r\n    boolHook = {\r\n        set: function( elem, value, name ) {\r\n            if ( value === false ) {\r\n\r\n                // Remove boolean attributes when set to false\r\n                jQuery.removeAttr( elem, name );\r\n            } else {\r\n                elem.setAttribute( name, name );\r\n            }\r\n            return name;\r\n        }\r\n    };\r\n\r\n    jQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( _i, name ) {\r\n        var getter = attrHandle[ name ] || jQuery.find.attr;\r\n\r\n        attrHandle[ name ] = function( elem, name, isXML ) {\r\n            var ret, handle,\r\n                lowercaseName = name.toLowerCase();\r\n\r\n            if ( !isXML ) {\r\n\r\n                // Avoid an infinite loop by temporarily removing this function from the getter\r\n                handle = attrHandle[ lowercaseName ];\r\n                attrHandle[ lowercaseName ] = ret;\r\n                ret = getter( elem, name, isXML ) != null ?\r\n                    lowercaseName :\r\n                    null;\r\n                attrHandle[ lowercaseName ] = handle;\r\n            }\r\n            return ret;\r\n        };\r\n    } );\r\n\r\n\r\n\r\n\r\n    var rfocusable = /^(?:input|select|textarea|button)$/i,\r\n        rclickable = /^(?:a|area)$/i;\r\n\r\n    jQuery.fn.extend( {\r\n        prop: function( name, value ) {\r\n            return access( this, jQuery.prop, name, value, arguments.length > 1 );\r\n        },\r\n\r\n        removeProp: function( name ) {\r\n            return this.each( function() {\r\n                delete this[ jQuery.propFix[ name ] || name ];\r\n            } );\r\n        }\r\n    } );\r\n\r\n    jQuery.extend( {\r\n        prop: function( elem, name, value ) {\r\n            var ret, hooks,\r\n                nType = elem.nodeType;\r\n\r\n            // Don't get/set properties on text, comment and attribute nodes\r\n            if ( nType === 3 || nType === 8 || nType === 2 ) {\r\n                return;\r\n            }\r\n\r\n            if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\r\n\r\n                // Fix name and attach hooks\r\n                name = jQuery.propFix[ name ] || name;\r\n                hooks = jQuery.propHooks[ name ];\r\n            }\r\n\r\n            if ( value !== undefined ) {\r\n                if ( hooks && \"set\" in hooks &&\r\n                    ( ret = hooks.set( elem, value, name ) ) !== undefined ) {\r\n                    return ret;\r\n                }\r\n\r\n                return ( elem[ name ] = value );\r\n            }\r\n\r\n            if ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\r\n                return ret;\r\n            }\r\n\r\n            return elem[ name ];\r\n        },\r\n\r\n        propHooks: {\r\n            tabIndex: {\r\n                get: function( elem ) {\r\n\r\n                    // Support: IE <=9 - 11 only\r\n                    // elem.tabIndex doesn't always return the\r\n                    // correct value when it hasn't been explicitly set\r\n                    // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\r\n                    // Use proper attribute retrieval(#12072)\r\n                    var tabindex = jQuery.find.attr( elem, \"tabindex\" );\r\n\r\n                    if ( tabindex ) {\r\n                        return parseInt( tabindex, 10 );\r\n                    }\r\n\r\n                    if (\r\n                        rfocusable.test( elem.nodeName ) ||\r\n                        rclickable.test( elem.nodeName ) &&\r\n                        elem.href\r\n                    ) {\r\n                        return 0;\r\n                    }\r\n\r\n                    return -1;\r\n                }\r\n            }\r\n        },\r\n\r\n        propFix: {\r\n            \"for\": \"htmlFor\",\r\n            \"class\": \"className\"\r\n        }\r\n    } );\r\n\r\n// Support: IE <=11 only\r\n// Accessing the selectedIndex property\r\n// forces the browser to respect setting selected\r\n// on the option\r\n// The getter ensures a default option is selected\r\n// when in an optgroup\r\n// eslint rule \"no-unused-expressions\" is disabled for this code\r\n// since it considers such accessions noop\r\n    if ( !support.optSelected ) {\r\n        jQuery.propHooks.selected = {\r\n            get: function( elem ) {\r\n\r\n                /* eslint no-unused-expressions: \"off\" */\r\n\r\n                var parent = elem.parentNode;\r\n                if ( parent && parent.parentNode ) {\r\n                    parent.parentNode.selectedIndex;\r\n                }\r\n                return null;\r\n            },\r\n            set: function( elem ) {\r\n\r\n                /* eslint no-unused-expressions: \"off\" */\r\n\r\n                var parent = elem.parentNode;\r\n                if ( parent ) {\r\n                    parent.selectedIndex;\r\n\r\n                    if ( parent.parentNode ) {\r\n                        parent.parentNode.selectedIndex;\r\n                    }\r\n                }\r\n            }\r\n        };\r\n    }\r\n\r\n    jQuery.each( [\r\n        \"tabIndex\",\r\n        \"readOnly\",\r\n        \"maxLength\",\r\n        \"cellSpacing\",\r\n        \"cellPadding\",\r\n        \"rowSpan\",\r\n        \"colSpan\",\r\n        \"useMap\",\r\n        \"frameBorder\",\r\n        \"contentEditable\"\r\n    ], function() {\r\n        jQuery.propFix[ this.toLowerCase() ] = this;\r\n    } );\r\n\r\n\r\n\r\n\r\n    // Strip and collapse whitespace according to HTML spec\r\n    // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\r\n    function stripAndCollapse( value ) {\r\n        var tokens = value.match( rnothtmlwhite ) || [];\r\n        return tokens.join( \" \" );\r\n    }\r\n\r\n\r\n    function getClass( elem ) {\r\n        return elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\r\n    }\r\n\r\n    function classesToArray( value ) {\r\n        if ( Array.isArray( value ) ) {\r\n            return value;\r\n        }\r\n        if ( typeof value === \"string\" ) {\r\n            return value.match( rnothtmlwhite ) || [];\r\n        }\r\n        return [];\r\n    }\r\n\r\n    jQuery.fn.extend( {\r\n        addClass: function( value ) {\r\n            var classes, elem, cur, curValue, clazz, j, finalValue,\r\n                i = 0;\r\n\r\n            if ( isFunction( value ) ) {\r\n                return this.each( function( j ) {\r\n                    jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\r\n                } );\r\n            }\r\n\r\n            classes = classesToArray( value );\r\n\r\n            if ( classes.length ) {\r\n                while ( ( elem = this[ i++ ] ) ) {\r\n                    curValue = getClass( elem );\r\n                    cur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\r\n\r\n                    if ( cur ) {\r\n                        j = 0;\r\n                        while ( ( clazz = classes[ j++ ] ) ) {\r\n                            if ( cur.indexOf( \" \" + clazz + \" \" ) < 0 ) {\r\n                                cur += clazz + \" \";\r\n                            }\r\n                        }\r\n\r\n                        // Only assign if different to avoid unneeded rendering.\r\n                        finalValue = stripAndCollapse( cur );\r\n                        if ( curValue !== finalValue ) {\r\n                            elem.setAttribute( \"class\", finalValue );\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return this;\r\n        },\r\n\r\n        removeClass: function( value ) {\r\n            var classes, elem, cur, curValue, clazz, j, finalValue,\r\n                i = 0;\r\n\r\n            if ( isFunction( value ) ) {\r\n                return this.each( function( j ) {\r\n                    jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\r\n                } );\r\n            }\r\n\r\n            if ( !arguments.length ) {\r\n                return this.attr( \"class\", \"\" );\r\n            }\r\n\r\n            classes = classesToArray( value );\r\n\r\n            if ( classes.length ) {\r\n                while ( ( elem = this[ i++ ] ) ) {\r\n                    curValue = getClass( elem );\r\n\r\n                    // This expression is here for better compressibility (see addClass)\r\n                    cur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\r\n\r\n                    if ( cur ) {\r\n                        j = 0;\r\n                        while ( ( clazz = classes[ j++ ] ) ) {\r\n\r\n                            // Remove *all* instances\r\n                            while ( cur.indexOf( \" \" + clazz + \" \" ) > -1 ) {\r\n                                cur = cur.replace( \" \" + clazz + \" \", \" \" );\r\n                            }\r\n                        }\r\n\r\n                        // Only assign if different to avoid unneeded rendering.\r\n                        finalValue = stripAndCollapse( cur );\r\n                        if ( curValue !== finalValue ) {\r\n                            elem.setAttribute( \"class\", finalValue );\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return this;\r\n        },\r\n\r\n        toggleClass: function( value, stateVal ) {\r\n            var type = typeof value,\r\n                isValidValue = type === \"string\" || Array.isArray( value );\r\n\r\n            if ( typeof stateVal === \"boolean\" && isValidValue ) {\r\n                return stateVal ? this.addClass( value ) : this.removeClass( value );\r\n            }\r\n\r\n            if ( isFunction( value ) ) {\r\n                return this.each( function( i ) {\r\n                    jQuery( this ).toggleClass(\r\n                        value.call( this, i, getClass( this ), stateVal ),\r\n                        stateVal\r\n                    );\r\n                } );\r\n            }\r\n\r\n            return this.each( function() {\r\n                var className, i, self, classNames;\r\n\r\n                if ( isValidValue ) {\r\n\r\n                    // Toggle individual class names\r\n                    i = 0;\r\n                    self = jQuery( this );\r\n                    classNames = classesToArray( value );\r\n\r\n                    while ( ( className = classNames[ i++ ] ) ) {\r\n\r\n                        // Check each className given, space separated list\r\n                        if ( self.hasClass( className ) ) {\r\n                            self.removeClass( className );\r\n                        } else {\r\n                            self.addClass( className );\r\n                        }\r\n                    }\r\n\r\n                    // Toggle whole class name\r\n                } else if ( value === undefined || type === \"boolean\" ) {\r\n                    className = getClass( this );\r\n                    if ( className ) {\r\n\r\n                        // Store className if set\r\n                        dataPriv.set( this, \"__className__\", className );\r\n                    }\r\n\r\n                    // If the element has a class name or if we're passed `false`,\r\n                    // then remove the whole classname (if there was one, the above saved it).\r\n                    // Otherwise bring back whatever was previously saved (if anything),\r\n                    // falling back to the empty string if nothing was stored.\r\n                    if ( this.setAttribute ) {\r\n                        this.setAttribute( \"class\",\r\n                            className || value === false ?\r\n                                \"\" :\r\n                                dataPriv.get( this, \"__className__\" ) || \"\"\r\n                        );\r\n                    }\r\n                }\r\n            } );\r\n        },\r\n\r\n        hasClass: function( selector ) {\r\n            var className, elem,\r\n                i = 0;\r\n\r\n            className = \" \" + selector + \" \";\r\n            while ( ( elem = this[ i++ ] ) ) {\r\n                if ( elem.nodeType === 1 &&\r\n                    ( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\r\n                    return true;\r\n                }\r\n            }\r\n\r\n            return false;\r\n        }\r\n    } );\r\n\r\n\r\n\r\n\r\n    var rreturn = /\\r/g;\r\n\r\n    jQuery.fn.extend( {\r\n        val: function( value ) {\r\n            var hooks, ret, valueIsFunction,\r\n                elem = this[ 0 ];\r\n\r\n            if ( !arguments.length ) {\r\n                if ( elem ) {\r\n                    hooks = jQuery.valHooks[ elem.type ] ||\r\n                        jQuery.valHooks[ elem.nodeName.toLowerCase() ];\r\n\r\n                    if ( hooks &&\r\n                        \"get\" in hooks &&\r\n                        ( ret = hooks.get( elem, \"value\" ) ) !== undefined\r\n                    ) {\r\n                        return ret;\r\n                    }\r\n\r\n                    ret = elem.value;\r\n\r\n                    // Handle most common string cases\r\n                    if ( typeof ret === \"string\" ) {\r\n                        return ret.replace( rreturn, \"\" );\r\n                    }\r\n\r\n                    // Handle cases where value is null/undef or number\r\n                    return ret == null ? \"\" : ret;\r\n                }\r\n\r\n                return;\r\n            }\r\n\r\n            valueIsFunction = isFunction( value );\r\n\r\n            return this.each( function( i ) {\r\n                var val;\r\n\r\n                if ( this.nodeType !== 1 ) {\r\n                    return;\r\n                }\r\n\r\n                if ( valueIsFunction ) {\r\n                    val = value.call( this, i, jQuery( this ).val() );\r\n                } else {\r\n                    val = value;\r\n                }\r\n\r\n                // Treat null/undefined as \"\"; convert numbers to string\r\n                if ( val == null ) {\r\n                    val = \"\";\r\n\r\n                } else if ( typeof val === \"number\" ) {\r\n                    val += \"\";\r\n\r\n                } else if ( Array.isArray( val ) ) {\r\n                    val = jQuery.map( val, function( value ) {\r\n                        return value == null ? \"\" : value + \"\";\r\n                    } );\r\n                }\r\n\r\n                hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\r\n\r\n                // If set returns undefined, fall back to normal setting\r\n                if ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\r\n                    this.value = val;\r\n                }\r\n            } );\r\n        }\r\n    } );\r\n\r\n    jQuery.extend( {\r\n        valHooks: {\r\n            option: {\r\n                get: function( elem ) {\r\n\r\n                    var val = jQuery.find.attr( elem, \"value\" );\r\n                    return val != null ?\r\n                        val :\r\n\r\n                        // Support: IE <=10 - 11 only\r\n                        // option.text throws exceptions (#14686, #14858)\r\n                        // Strip and collapse whitespace\r\n                        // https://html.spec.whatwg.org/#strip-and-collapse-whitespace\r\n                        stripAndCollapse( jQuery.text( elem ) );\r\n                }\r\n            },\r\n            select: {\r\n                get: function( elem ) {\r\n                    var value, option, i,\r\n                        options = elem.options,\r\n                        index = elem.selectedIndex,\r\n                        one = elem.type === \"select-one\",\r\n                        values = one ? null : [],\r\n                        max = one ? index + 1 : options.length;\r\n\r\n                    if ( index < 0 ) {\r\n                        i = max;\r\n\r\n                    } else {\r\n                        i = one ? index : 0;\r\n                    }\r\n\r\n                    // Loop through all the selected options\r\n                    for ( ; i < max; i++ ) {\r\n                        option = options[ i ];\r\n\r\n                        // Support: IE <=9 only\r\n                        // IE8-9 doesn't update selected after form reset (#2551)\r\n                        if ( ( option.selected || i === index ) &&\r\n\r\n                            // Don't return options that are disabled or in a disabled optgroup\r\n                            !option.disabled &&\r\n                            ( !option.parentNode.disabled ||\r\n                                !nodeName( option.parentNode, \"optgroup\" ) ) ) {\r\n\r\n                            // Get the specific value for the option\r\n                            value = jQuery( option ).val();\r\n\r\n                            // We don't need an array for one selects\r\n                            if ( one ) {\r\n                                return value;\r\n                            }\r\n\r\n                            // Multi-Selects return an array\r\n                            values.push( value );\r\n                        }\r\n                    }\r\n\r\n                    return values;\r\n                },\r\n\r\n                set: function( elem, value ) {\r\n                    var optionSet, option,\r\n                        options = elem.options,\r\n                        values = jQuery.makeArray( value ),\r\n                        i = options.length;\r\n\r\n                    while ( i-- ) {\r\n                        option = options[ i ];\r\n\r\n                        /* eslint-disable no-cond-assign */\r\n\r\n                        if ( option.selected =\r\n                            jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\r\n                        ) {\r\n                            optionSet = true;\r\n                        }\r\n\r\n                        /* eslint-enable no-cond-assign */\r\n                    }\r\n\r\n                    // Force browsers to behave consistently when non-matching value is set\r\n                    if ( !optionSet ) {\r\n                        elem.selectedIndex = -1;\r\n                    }\r\n                    return values;\r\n                }\r\n            }\r\n        }\r\n    } );\r\n\r\n// Radios and checkboxes getter/setter\r\n    jQuery.each( [ \"radio\", \"checkbox\" ], function() {\r\n        jQuery.valHooks[ this ] = {\r\n            set: function( elem, value ) {\r\n                if ( Array.isArray( value ) ) {\r\n                    return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\r\n                }\r\n            }\r\n        };\r\n        if ( !support.checkOn ) {\r\n            jQuery.valHooks[ this ].get = function( elem ) {\r\n                return elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\r\n            };\r\n        }\r\n    } );\r\n\r\n\r\n\r\n\r\n// Return jQuery for attributes-only inclusion\r\n\r\n\r\n    support.focusin = \"onfocusin\" in window;\r\n\r\n\r\n    var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\r\n        stopPropagationCallback = function( e ) {\r\n            e.stopPropagation();\r\n        };\r\n\r\n    jQuery.extend( jQuery.event, {\r\n\r\n        trigger: function( event, data, elem, onlyHandlers ) {\r\n\r\n            var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\r\n                eventPath = [ elem || document ],\r\n                type = hasOwn.call( event, \"type\" ) ? event.type : event,\r\n                namespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\r\n\r\n            cur = lastElement = tmp = elem = elem || document;\r\n\r\n            // Don't do events on text and comment nodes\r\n            if ( elem.nodeType === 3 || elem.nodeType === 8 ) {\r\n                return;\r\n            }\r\n\r\n            // focus/blur morphs to focusin/out; ensure we're not firing them right now\r\n            if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\r\n                return;\r\n            }\r\n\r\n            if ( type.indexOf( \".\" ) > -1 ) {\r\n\r\n                // Namespaced trigger; create a regexp to match event type in handle()\r\n                namespaces = type.split( \".\" );\r\n                type = namespaces.shift();\r\n                namespaces.sort();\r\n            }\r\n            ontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\r\n\r\n            // Caller can pass in a jQuery.Event object, Object, or just an event type string\r\n            event = event[ jQuery.expando ] ?\r\n                event :\r\n                new jQuery.Event( type, typeof event === \"object\" && event );\r\n\r\n            // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\r\n            event.isTrigger = onlyHandlers ? 2 : 3;\r\n            event.namespace = namespaces.join( \".\" );\r\n            event.rnamespace = event.namespace ?\r\n                new RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\r\n                null;\r\n\r\n            // Clean up the event in case it is being reused\r\n            event.result = undefined;\r\n            if ( !event.target ) {\r\n                event.target = elem;\r\n            }\r\n\r\n            // Clone any incoming data and prepend the event, creating the handler arg list\r\n            data = data == null ?\r\n                [ event ] :\r\n                jQuery.makeArray( data, [ event ] );\r\n\r\n            // Allow special events to draw outside the lines\r\n            special = jQuery.event.special[ type ] || {};\r\n            if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\r\n                return;\r\n            }\r\n\r\n            // Determine event propagation path in advance, per W3C events spec (#9951)\r\n            // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\r\n            if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\r\n\r\n                bubbleType = special.delegateType || type;\r\n                if ( !rfocusMorph.test( bubbleType + type ) ) {\r\n                    cur = cur.parentNode;\r\n                }\r\n                for ( ; cur; cur = cur.parentNode ) {\r\n                    eventPath.push( cur );\r\n                    tmp = cur;\r\n                }\r\n\r\n                // Only add window if we got to document (e.g., not plain obj or detached DOM)\r\n                if ( tmp === ( elem.ownerDocument || document ) ) {\r\n                    eventPath.push( tmp.defaultView || tmp.parentWindow || window );\r\n                }\r\n            }\r\n\r\n            // Fire handlers on the event path\r\n            i = 0;\r\n            while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\r\n                lastElement = cur;\r\n                event.type = i > 1 ?\r\n                    bubbleType :\r\n                    special.bindType || type;\r\n\r\n                // jQuery handler\r\n                handle = ( dataPriv.get( cur, \"events\" ) || Object.create( null ) )[ event.type ] &&\r\n                    dataPriv.get( cur, \"handle\" );\r\n                if ( handle ) {\r\n                    handle.apply( cur, data );\r\n                }\r\n\r\n                // Native handler\r\n                handle = ontype && cur[ ontype ];\r\n                if ( handle && handle.apply && acceptData( cur ) ) {\r\n                    event.result = handle.apply( cur, data );\r\n                    if ( event.result === false ) {\r\n                        event.preventDefault();\r\n                    }\r\n                }\r\n            }\r\n            event.type = type;\r\n\r\n            // If nobody prevented the default action, do it now\r\n            if ( !onlyHandlers && !event.isDefaultPrevented() ) {\r\n\r\n                if ( ( !special._default ||\r\n                        special._default.apply( eventPath.pop(), data ) === false ) &&\r\n                    acceptData( elem ) ) {\r\n\r\n                    // Call a native DOM method on the target with the same name as the event.\r\n                    // Don't do default actions on window, that's where global variables be (#6170)\r\n                    if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {\r\n\r\n                        // Don't re-trigger an onFOO event when we call its FOO() method\r\n                        tmp = elem[ ontype ];\r\n\r\n                        if ( tmp ) {\r\n                            elem[ ontype ] = null;\r\n                        }\r\n\r\n                        // Prevent re-triggering of the same event, since we already bubbled it above\r\n                        jQuery.event.triggered = type;\r\n\r\n                        if ( event.isPropagationStopped() ) {\r\n                            lastElement.addEventListener( type, stopPropagationCallback );\r\n                        }\r\n\r\n                        elem[ type ]();\r\n\r\n                        if ( event.isPropagationStopped() ) {\r\n                            lastElement.removeEventListener( type, stopPropagationCallback );\r\n                        }\r\n\r\n                        jQuery.event.triggered = undefined;\r\n\r\n                        if ( tmp ) {\r\n                            elem[ ontype ] = tmp;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return event.result;\r\n        },\r\n\r\n        // Piggyback on a donor event to simulate a different one\r\n        // Used only for `focus(in | out)` events\r\n        simulate: function( type, elem, event ) {\r\n            var e = jQuery.extend(\r\n                new jQuery.Event(),\r\n                event,\r\n                {\r\n                    type: type,\r\n                    isSimulated: true\r\n                }\r\n            );\r\n\r\n            jQuery.event.trigger( e, null, elem );\r\n        }\r\n\r\n    } );\r\n\r\n    jQuery.fn.extend( {\r\n\r\n        trigger: function( type, data ) {\r\n            return this.each( function() {\r\n                jQuery.event.trigger( type, data, this );\r\n            } );\r\n        },\r\n        triggerHandler: function( type, data ) {\r\n            var elem = this[ 0 ];\r\n            if ( elem ) {\r\n                return jQuery.event.trigger( type, data, elem, true );\r\n            }\r\n        }\r\n    } );\r\n\r\n\r\n// Support: Firefox <=44\r\n// Firefox doesn't have focus(in | out) events\r\n// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\r\n//\r\n// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\r\n// focus(in | out) events fire after focus & blur events,\r\n// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\r\n// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\r\n    if ( !support.focusin ) {\r\n        jQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\r\n\r\n            // Attach a single capturing handler on the document while someone wants focusin/focusout\r\n            var handler = function( event ) {\r\n                jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );\r\n            };\r\n\r\n            jQuery.event.special[ fix ] = {\r\n                setup: function() {\r\n\r\n                    // Handle: regular nodes (via `this.ownerDocument`), window\r\n                    // (via `this.document`) & document (via `this`).\r\n                    var doc = this.ownerDocument || this.document || this,\r\n                        attaches = dataPriv.access( doc, fix );\r\n\r\n                    if ( !attaches ) {\r\n                        doc.addEventListener( orig, handler, true );\r\n                    }\r\n                    dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );\r\n                },\r\n                teardown: function() {\r\n                    var doc = this.ownerDocument || this.document || this,\r\n                        attaches = dataPriv.access( doc, fix ) - 1;\r\n\r\n                    if ( !attaches ) {\r\n                        doc.removeEventListener( orig, handler, true );\r\n                        dataPriv.remove( doc, fix );\r\n\r\n                    } else {\r\n                        dataPriv.access( doc, fix, attaches );\r\n                    }\r\n                }\r\n            };\r\n        } );\r\n    }\r\n    var location = window.location;\r\n\r\n    var nonce = { guid: Date.now() };\r\n\r\n    var rquery = ( /\\?/ );\r\n\r\n\r\n\r\n// Cross-browser xml parsing\r\n    jQuery.parseXML = function( data ) {\r\n        var xml, parserErrorElem;\r\n        if ( !data || typeof data !== \"string\" ) {\r\n            return null;\r\n        }\r\n\r\n        // Support: IE 9 - 11 only\r\n        // IE throws on parseFromString with invalid input.\r\n        try {\r\n            xml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\r\n        } catch ( e ) {}\r\n\r\n        parserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\r\n        if ( !xml || parserErrorElem ) {\r\n            jQuery.error( \"Invalid XML: \" + (\r\n                parserErrorElem ?\r\n                    jQuery.map( parserErrorElem.childNodes, function( el ) {\r\n                        return el.textContent;\r\n                    } ).join( \"\\n\" ) :\r\n                    data\r\n            ) );\r\n        }\r\n        return xml;\r\n    };\r\n\r\n\r\n    var\r\n        rbracket = /\\[\\]$/,\r\n        rCRLF = /\\r?\\n/g,\r\n        rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\r\n        rsubmittable = /^(?:input|select|textarea|keygen)/i;\r\n\r\n    function buildParams( prefix, obj, traditional, add ) {\r\n        var name;\r\n\r\n        if ( Array.isArray( obj ) ) {\r\n\r\n            // Serialize array item.\r\n            jQuery.each( obj, function( i, v ) {\r\n                if ( traditional || rbracket.test( prefix ) ) {\r\n\r\n                    // Treat each array item as a scalar.\r\n                    add( prefix, v );\r\n\r\n                } else {\r\n\r\n                    // Item is non-scalar (array or object), encode its numeric index.\r\n                    buildParams(\r\n                        prefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\r\n                        v,\r\n                        traditional,\r\n                        add\r\n                    );\r\n                }\r\n            } );\r\n\r\n        } else if ( !traditional && toType( obj ) === \"object\" ) {\r\n\r\n            // Serialize object item.\r\n            for ( name in obj ) {\r\n                buildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\r\n            }\r\n\r\n        } else {\r\n\r\n            // Serialize scalar item.\r\n            add( prefix, obj );\r\n        }\r\n    }\r\n\r\n// Serialize an array of form elements or a set of\r\n// key/values into a query string\r\n    jQuery.param = function( a, traditional ) {\r\n        var prefix,\r\n            s = [],\r\n            add = function( key, valueOrFunction ) {\r\n\r\n                // If value is a function, invoke it and use its return value\r\n                var value = isFunction( valueOrFunction ) ?\r\n                    valueOrFunction() :\r\n                    valueOrFunction;\r\n\r\n                s[ s.length ] = encodeURIComponent( key ) + \"=\" +\r\n                    encodeURIComponent( value == null ? \"\" : value );\r\n            };\r\n\r\n        if ( a == null ) {\r\n            return \"\";\r\n        }\r\n\r\n        // If an array was passed in, assume that it is an array of form elements.\r\n        if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\r\n\r\n            // Serialize the form elements\r\n            jQuery.each( a, function() {\r\n                add( this.name, this.value );\r\n            } );\r\n\r\n        } else {\r\n\r\n            // If traditional, encode the \"old\" way (the way 1.3.2 or older\r\n            // did it), otherwise encode params recursively.\r\n            for ( prefix in a ) {\r\n                buildParams( prefix, a[ prefix ], traditional, add );\r\n            }\r\n        }\r\n\r\n        // Return the resulting serialization\r\n        return s.join( \"&\" );\r\n    };\r\n\r\n    jQuery.fn.extend( {\r\n        serialize: function() {\r\n            return jQuery.param( this.serializeArray() );\r\n        },\r\n        serializeArray: function() {\r\n            return this.map( function() {\r\n\r\n                // Can add propHook for \"elements\" to filter or add form elements\r\n                var elements = jQuery.prop( this, \"elements\" );\r\n                return elements ? jQuery.makeArray( elements ) : this;\r\n            } ).filter( function() {\r\n                var type = this.type;\r\n\r\n                // Use .is( \":disabled\" ) so that fieldset[disabled] works\r\n                return this.name && !jQuery( this ).is( \":disabled\" ) &&\r\n                    rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\r\n                    ( this.checked || !rcheckableType.test( type ) );\r\n            } ).map( function( _i, elem ) {\r\n                var val = jQuery( this ).val();\r\n\r\n                if ( val == null ) {\r\n                    return null;\r\n                }\r\n\r\n                if ( Array.isArray( val ) ) {\r\n                    return jQuery.map( val, function( val ) {\r\n                        return { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\r\n                    } );\r\n                }\r\n\r\n                return { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\r\n            } ).get();\r\n        }\r\n    } );\r\n\r\n\r\n    var\r\n        r20 = /%20/g,\r\n        rhash = /#.*$/,\r\n        rantiCache = /([?&])_=[^&]*/,\r\n        rheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\r\n\r\n        // #7653, #8125, #8152: local protocol detection\r\n        rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\r\n        rnoContent = /^(?:GET|HEAD)$/,\r\n        rprotocol = /^\\/\\//,\r\n\r\n        /* Prefilters\r\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\r\n\t * 2) These are called:\r\n\t *    - BEFORE asking for a transport\r\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\r\n\t * 3) key is the dataType\r\n\t * 4) the catchall symbol \"*\" can be used\r\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\r\n\t */\r\n        prefilters = {},\r\n\r\n        /* Transports bindings\r\n\t * 1) key is the dataType\r\n\t * 2) the catchall symbol \"*\" can be used\r\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\r\n\t */\r\n        transports = {},\r\n\r\n        // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\r\n        allTypes = \"*/\".concat( \"*\" ),\r\n\r\n        // Anchor tag for parsing the document origin\r\n        originAnchor = document.createElement( \"a\" );\r\n\r\n    originAnchor.href = location.href;\r\n\r\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\r\n    function addToPrefiltersOrTransports( structure ) {\r\n\r\n        // dataTypeExpression is optional and defaults to \"*\"\r\n        return function( dataTypeExpression, func ) {\r\n\r\n            if ( typeof dataTypeExpression !== \"string\" ) {\r\n                func = dataTypeExpression;\r\n                dataTypeExpression = \"*\";\r\n            }\r\n\r\n            var dataType,\r\n                i = 0,\r\n                dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\r\n\r\n            if ( isFunction( func ) ) {\r\n\r\n                // For each dataType in the dataTypeExpression\r\n                while ( ( dataType = dataTypes[ i++ ] ) ) {\r\n\r\n                    // Prepend if requested\r\n                    if ( dataType[ 0 ] === \"+\" ) {\r\n                        dataType = dataType.slice( 1 ) || \"*\";\r\n                        ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\r\n\r\n                        // Otherwise append\r\n                    } else {\r\n                        ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\r\n                    }\r\n                }\r\n            }\r\n        };\r\n    }\r\n\r\n// Base inspection function for prefilters and transports\r\n    function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\r\n\r\n        var inspected = {},\r\n            seekingTransport = ( structure === transports );\r\n\r\n        function inspect( dataType ) {\r\n            var selected;\r\n            inspected[ dataType ] = true;\r\n            jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\r\n                var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\r\n                if ( typeof dataTypeOrTransport === \"string\" &&\r\n                    !seekingTransport && !inspected[ dataTypeOrTransport ] ) {\r\n\r\n                    options.dataTypes.unshift( dataTypeOrTransport );\r\n                    inspect( dataTypeOrTransport );\r\n                    return false;\r\n                } else if ( seekingTransport ) {\r\n                    return !( selected = dataTypeOrTransport );\r\n                }\r\n            } );\r\n            return selected;\r\n        }\r\n\r\n        return inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\r\n    }\r\n\r\n// A special extend for ajax options\r\n// that takes \"flat\" options (not to be deep extended)\r\n// Fixes #9887\r\n    function ajaxExtend( target, src ) {\r\n        var key, deep,\r\n            flatOptions = jQuery.ajaxSettings.flatOptions || {};\r\n\r\n        for ( key in src ) {\r\n            if ( src[ key ] !== undefined ) {\r\n                ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\r\n            }\r\n        }\r\n        if ( deep ) {\r\n            jQuery.extend( true, target, deep );\r\n        }\r\n\r\n        return target;\r\n    }\r\n\r\n    /* Handles responses to an ajax request:\r\n * - finds the right dataType (mediates between content-type and expected dataType)\r\n * - returns the corresponding response\r\n */\r\n    function ajaxHandleResponses( s, jqXHR, responses ) {\r\n\r\n        var ct, type, finalDataType, firstDataType,\r\n            contents = s.contents,\r\n            dataTypes = s.dataTypes;\r\n\r\n        // Remove auto dataType and get content-type in the process\r\n        while ( dataTypes[ 0 ] === \"*\" ) {\r\n            dataTypes.shift();\r\n            if ( ct === undefined ) {\r\n                ct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\r\n            }\r\n        }\r\n\r\n        // Check if we're dealing with a known content-type\r\n        if ( ct ) {\r\n            for ( type in contents ) {\r\n                if ( contents[ type ] && contents[ type ].test( ct ) ) {\r\n                    dataTypes.unshift( type );\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n\r\n        // Check to see if we have a response for the expected dataType\r\n        if ( dataTypes[ 0 ] in responses ) {\r\n            finalDataType = dataTypes[ 0 ];\r\n        } else {\r\n\r\n            // Try convertible dataTypes\r\n            for ( type in responses ) {\r\n                if ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\r\n                    finalDataType = type;\r\n                    break;\r\n                }\r\n                if ( !firstDataType ) {\r\n                    firstDataType = type;\r\n                }\r\n            }\r\n\r\n            // Or just use first one\r\n            finalDataType = finalDataType || firstDataType;\r\n        }\r\n\r\n        // If we found a dataType\r\n        // We add the dataType to the list if needed\r\n        // and return the corresponding response\r\n        if ( finalDataType ) {\r\n            if ( finalDataType !== dataTypes[ 0 ] ) {\r\n                dataTypes.unshift( finalDataType );\r\n            }\r\n            return responses[ finalDataType ];\r\n        }\r\n    }\r\n\r\n    /* Chain conversions given the request and the original response\r\n * Also sets the responseXXX fields on the jqXHR instance\r\n */\r\n    function ajaxConvert( s, response, jqXHR, isSuccess ) {\r\n        var conv2, current, conv, tmp, prev,\r\n            converters = {},\r\n\r\n            // Work with a copy of dataTypes in case we need to modify it for conversion\r\n            dataTypes = s.dataTypes.slice();\r\n\r\n        // Create converters map with lowercased keys\r\n        if ( dataTypes[ 1 ] ) {\r\n            for ( conv in s.converters ) {\r\n                converters[ conv.toLowerCase() ] = s.converters[ conv ];\r\n            }\r\n        }\r\n\r\n        current = dataTypes.shift();\r\n\r\n        // Convert to each sequential dataType\r\n        while ( current ) {\r\n\r\n            if ( s.responseFields[ current ] ) {\r\n                jqXHR[ s.responseFields[ current ] ] = response;\r\n            }\r\n\r\n            // Apply the dataFilter if provided\r\n            if ( !prev && isSuccess && s.dataFilter ) {\r\n                response = s.dataFilter( response, s.dataType );\r\n            }\r\n\r\n            prev = current;\r\n            current = dataTypes.shift();\r\n\r\n            if ( current ) {\r\n\r\n                // There's only work to do if current dataType is non-auto\r\n                if ( current === \"*\" ) {\r\n\r\n                    current = prev;\r\n\r\n                    // Convert response if prev dataType is non-auto and differs from current\r\n                } else if ( prev !== \"*\" && prev !== current ) {\r\n\r\n                    // Seek a direct converter\r\n                    conv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\r\n\r\n                    // If none found, seek a pair\r\n                    if ( !conv ) {\r\n                        for ( conv2 in converters ) {\r\n\r\n                            // If conv2 outputs current\r\n                            tmp = conv2.split( \" \" );\r\n                            if ( tmp[ 1 ] === current ) {\r\n\r\n                                // If prev can be converted to accepted input\r\n                                conv = converters[ prev + \" \" + tmp[ 0 ] ] ||\r\n                                    converters[ \"* \" + tmp[ 0 ] ];\r\n                                if ( conv ) {\r\n\r\n                                    // Condense equivalence converters\r\n                                    if ( conv === true ) {\r\n                                        conv = converters[ conv2 ];\r\n\r\n                                        // Otherwise, insert the intermediate dataType\r\n                                    } else if ( converters[ conv2 ] !== true ) {\r\n                                        current = tmp[ 0 ];\r\n                                        dataTypes.unshift( tmp[ 1 ] );\r\n                                    }\r\n                                    break;\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    // Apply converter (if not an equivalence)\r\n                    if ( conv !== true ) {\r\n\r\n                        // Unless errors are allowed to bubble, catch and return them\r\n                        if ( conv && s.throws ) {\r\n                            response = conv( response );\r\n                        } else {\r\n                            try {\r\n                                response = conv( response );\r\n                            } catch ( e ) {\r\n                                return {\r\n                                    state: \"parsererror\",\r\n                                    error: conv ? e : \"No conversion from \" + prev + \" to \" + current\r\n                                };\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return { state: \"success\", data: response };\r\n    }\r\n\r\n    jQuery.extend( {\r\n\r\n        // Counter for holding the number of active queries\r\n        active: 0,\r\n\r\n        // Last-Modified header cache for next request\r\n        lastModified: {},\r\n        etag: {},\r\n\r\n        ajaxSettings: {\r\n            url: location.href,\r\n            type: \"GET\",\r\n            isLocal: rlocalProtocol.test( location.protocol ),\r\n            global: true,\r\n            processData: true,\r\n            async: true,\r\n            contentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\r\n\r\n            /*\r\n\t\ttimeout: 0,\r\n\t\tdata: null,\r\n\t\tdataType: null,\r\n\t\tusername: null,\r\n\t\tpassword: null,\r\n\t\tcache: null,\r\n\t\tthrows: false,\r\n\t\ttraditional: false,\r\n\t\theaders: {},\r\n\t\t*/\r\n\r\n            accepts: {\r\n                \"*\": allTypes,\r\n                text: \"text/plain\",\r\n                html: \"text/html\",\r\n                xml: \"application/xml, text/xml\",\r\n                json: \"application/json, text/javascript\"\r\n            },\r\n\r\n            contents: {\r\n                xml: /\\bxml\\b/,\r\n                html: /\\bhtml/,\r\n                json: /\\bjson\\b/\r\n            },\r\n\r\n            responseFields: {\r\n                xml: \"responseXML\",\r\n                text: \"responseText\",\r\n                json: \"responseJSON\"\r\n            },\r\n\r\n            // Data converters\r\n            // Keys separate source (or catchall \"*\") and destination types with a single space\r\n            converters: {\r\n\r\n                // Convert anything to text\r\n                \"* text\": String,\r\n\r\n                // Text to html (true = no transformation)\r\n                \"text html\": true,\r\n\r\n                // Evaluate text as a json expression\r\n                \"text json\": JSON.parse,\r\n\r\n                // Parse text as xml\r\n                \"text xml\": jQuery.parseXML\r\n            },\r\n\r\n            // For options that shouldn't be deep extended:\r\n            // you can add your own custom options here if\r\n            // and when you create one that shouldn't be\r\n            // deep extended (see ajaxExtend)\r\n            flatOptions: {\r\n                url: true,\r\n                context: true\r\n            }\r\n        },\r\n\r\n        // Creates a full fledged settings object into target\r\n        // with both ajaxSettings and settings fields.\r\n        // If target is omitted, writes into ajaxSettings.\r\n        ajaxSetup: function( target, settings ) {\r\n            return settings ?\r\n\r\n                // Building a settings object\r\n                ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\r\n\r\n                // Extending ajaxSettings\r\n                ajaxExtend( jQuery.ajaxSettings, target );\r\n        },\r\n\r\n        ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\r\n        ajaxTransport: addToPrefiltersOrTransports( transports ),\r\n\r\n        // Main method\r\n        ajax: function( url, options ) {\r\n\r\n            // If url is an object, simulate pre-1.5 signature\r\n            if ( typeof url === \"object\" ) {\r\n                options = url;\r\n                url = undefined;\r\n            }\r\n\r\n            // Force options to be an object\r\n            options = options || {};\r\n\r\n            var transport,\r\n\r\n                // URL without anti-cache param\r\n                cacheURL,\r\n\r\n                // Response headers\r\n                responseHeadersString,\r\n                responseHeaders,\r\n\r\n                // timeout handle\r\n                timeoutTimer,\r\n\r\n                // Url cleanup var\r\n                urlAnchor,\r\n\r\n                // Request state (becomes false upon send and true upon completion)\r\n                completed,\r\n\r\n                // To know if global events are to be dispatched\r\n                fireGlobals,\r\n\r\n                // Loop variable\r\n                i,\r\n\r\n                // uncached part of the url\r\n                uncached,\r\n\r\n                // Create the final options object\r\n                s = jQuery.ajaxSetup( {}, options ),\r\n\r\n                // Callbacks context\r\n                callbackContext = s.context || s,\r\n\r\n                // Context for global events is callbackContext if it is a DOM node or jQuery collection\r\n                globalEventContext = s.context &&\r\n                ( callbackContext.nodeType || callbackContext.jquery ) ?\r\n                    jQuery( callbackContext ) :\r\n                    jQuery.event,\r\n\r\n                // Deferreds\r\n                deferred = jQuery.Deferred(),\r\n                completeDeferred = jQuery.Callbacks( \"once memory\" ),\r\n\r\n                // Status-dependent callbacks\r\n                statusCode = s.statusCode || {},\r\n\r\n                // Headers (they are sent all at once)\r\n                requestHeaders = {},\r\n                requestHeadersNames = {},\r\n\r\n                // Default abort message\r\n                strAbort = \"canceled\",\r\n\r\n                // Fake xhr\r\n                jqXHR = {\r\n                    readyState: 0,\r\n\r\n                    // Builds headers hashtable if needed\r\n                    getResponseHeader: function( key ) {\r\n                        var match;\r\n                        if ( completed ) {\r\n                            if ( !responseHeaders ) {\r\n                                responseHeaders = {};\r\n                                while ( ( match = rheaders.exec( responseHeadersString ) ) ) {\r\n                                    responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\r\n                                        ( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\r\n                                            .concat( match[ 2 ] );\r\n                                }\r\n                            }\r\n                            match = responseHeaders[ key.toLowerCase() + \" \" ];\r\n                        }\r\n                        return match == null ? null : match.join( \", \" );\r\n                    },\r\n\r\n                    // Raw string\r\n                    getAllResponseHeaders: function() {\r\n                        return completed ? responseHeadersString : null;\r\n                    },\r\n\r\n                    // Caches the header\r\n                    setRequestHeader: function( name, value ) {\r\n                        if ( completed == null ) {\r\n                            name = requestHeadersNames[ name.toLowerCase() ] =\r\n                                requestHeadersNames[ name.toLowerCase() ] || name;\r\n                            requestHeaders[ name ] = value;\r\n                        }\r\n                        return this;\r\n                    },\r\n\r\n                    // Overrides response content-type header\r\n                    overrideMimeType: function( type ) {\r\n                        if ( completed == null ) {\r\n                            s.mimeType = type;\r\n                        }\r\n                        return this;\r\n                    },\r\n\r\n                    // Status-dependent callbacks\r\n                    statusCode: function( map ) {\r\n                        var code;\r\n                        if ( map ) {\r\n                            if ( completed ) {\r\n\r\n                                // Execute the appropriate callbacks\r\n                                jqXHR.always( map[ jqXHR.status ] );\r\n                            } else {\r\n\r\n                                // Lazy-add the new callbacks in a way that preserves old ones\r\n                                for ( code in map ) {\r\n                                    statusCode[ code ] = [ statusCode[ code ], map[ code ] ];\r\n                                }\r\n                            }\r\n                        }\r\n                        return this;\r\n                    },\r\n\r\n                    // Cancel the request\r\n                    abort: function( statusText ) {\r\n                        var finalText = statusText || strAbort;\r\n                        if ( transport ) {\r\n                            transport.abort( finalText );\r\n                        }\r\n                        done( 0, finalText );\r\n                        return this;\r\n                    }\r\n                };\r\n\r\n            // Attach deferreds\r\n            deferred.promise( jqXHR );\r\n\r\n            // Add protocol if not provided (prefilters might expect it)\r\n            // Handle falsy url in the settings object (#10093: consistency with old signature)\r\n            // We also use the url parameter if available\r\n            s.url = ( ( url || s.url || location.href ) + \"\" )\r\n                .replace( rprotocol, location.protocol + \"//\" );\r\n\r\n            // Alias method option to type as per ticket #12004\r\n            s.type = options.method || options.type || s.method || s.type;\r\n\r\n            // Extract dataTypes list\r\n            s.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\r\n\r\n            // A cross-domain request is in order when the origin doesn't match the current origin.\r\n            if ( s.crossDomain == null ) {\r\n                urlAnchor = document.createElement( \"a\" );\r\n\r\n                // Support: IE <=8 - 11, Edge 12 - 15\r\n                // IE throws exception on accessing the href property if url is malformed,\r\n                // e.g. http://example.com:80x/\r\n                try {\r\n                    urlAnchor.href = s.url;\r\n\r\n                    // Support: IE <=8 - 11 only\r\n                    // Anchor's host property isn't correctly set when s.url is relative\r\n                    urlAnchor.href = urlAnchor.href;\r\n                    s.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\r\n                        urlAnchor.protocol + \"//\" + urlAnchor.host;\r\n                } catch ( e ) {\r\n\r\n                    // If there is an error parsing the URL, assume it is crossDomain,\r\n                    // it can be rejected by the transport if it is invalid\r\n                    s.crossDomain = true;\r\n                }\r\n            }\r\n\r\n            // Convert data if not already a string\r\n            if ( s.data && s.processData && typeof s.data !== \"string\" ) {\r\n                s.data = jQuery.param( s.data, s.traditional );\r\n            }\r\n\r\n            // Apply prefilters\r\n            inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\r\n\r\n            // If request was aborted inside a prefilter, stop there\r\n            if ( completed ) {\r\n                return jqXHR;\r\n            }\r\n\r\n            // We can fire global events as of now if asked to\r\n            // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\r\n            fireGlobals = jQuery.event && s.global;\r\n\r\n            // Watch for a new set of requests\r\n            if ( fireGlobals && jQuery.active++ === 0 ) {\r\n                jQuery.event.trigger( \"ajaxStart\" );\r\n            }\r\n\r\n            // Uppercase the type\r\n            s.type = s.type.toUpperCase();\r\n\r\n            // Determine if request has content\r\n            s.hasContent = !rnoContent.test( s.type );\r\n\r\n            // Save the URL in case we're toying with the If-Modified-Since\r\n            // and/or If-None-Match header later on\r\n            // Remove hash to simplify url manipulation\r\n            cacheURL = s.url.replace( rhash, \"\" );\r\n\r\n            // More options handling for requests with no content\r\n            if ( !s.hasContent ) {\r\n\r\n                // Remember the hash so we can put it back\r\n                uncached = s.url.slice( cacheURL.length );\r\n\r\n                // If data is available and should be processed, append data to url\r\n                if ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\r\n                    cacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\r\n\r\n                    // #9682: remove data so that it's not used in an eventual retry\r\n                    delete s.data;\r\n                }\r\n\r\n                // Add or update anti-cache param if needed\r\n                if ( s.cache === false ) {\r\n                    cacheURL = cacheURL.replace( rantiCache, \"$1\" );\r\n                    uncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce.guid++ ) +\r\n                        uncached;\r\n                }\r\n\r\n                // Put hash and anti-cache on the URL that will be requested (gh-1732)\r\n                s.url = cacheURL + uncached;\r\n\r\n                // Change '%20' to '+' if this is encoded form body content (gh-2658)\r\n            } else if ( s.data && s.processData &&\r\n                ( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\r\n                s.data = s.data.replace( r20, \"+\" );\r\n            }\r\n\r\n            // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\r\n            if ( s.ifModified ) {\r\n                if ( jQuery.lastModified[ cacheURL ] ) {\r\n                    jqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\r\n                }\r\n                if ( jQuery.etag[ cacheURL ] ) {\r\n                    jqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\r\n                }\r\n            }\r\n\r\n            // Set the correct header, if data is being sent\r\n            if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\r\n                jqXHR.setRequestHeader( \"Content-Type\", s.contentType );\r\n            }\r\n\r\n            // Set the Accepts header for the server, depending on the dataType\r\n            jqXHR.setRequestHeader(\r\n                \"Accept\",\r\n                s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\r\n                    s.accepts[ s.dataTypes[ 0 ] ] +\r\n                    ( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\r\n                    s.accepts[ \"*\" ]\r\n            );\r\n\r\n            // Check for headers option\r\n            for ( i in s.headers ) {\r\n                jqXHR.setRequestHeader( i, s.headers[ i ] );\r\n            }\r\n\r\n            // Allow custom headers/mimetypes and early abort\r\n            if ( s.beforeSend &&\r\n                ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\r\n\r\n                // Abort if not done already and return\r\n                return jqXHR.abort();\r\n            }\r\n\r\n            // Aborting is no longer a cancellation\r\n            strAbort = \"abort\";\r\n\r\n            // Install callbacks on deferreds\r\n            completeDeferred.add( s.complete );\r\n            jqXHR.done( s.success );\r\n            jqXHR.fail( s.error );\r\n\r\n            // Get transport\r\n            transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\r\n\r\n            // If no transport, we auto-abort\r\n            if ( !transport ) {\r\n                done( -1, \"No Transport\" );\r\n            } else {\r\n                jqXHR.readyState = 1;\r\n\r\n                // Send global event\r\n                if ( fireGlobals ) {\r\n                    globalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\r\n                }\r\n\r\n                // If request was aborted inside ajaxSend, stop there\r\n                if ( completed ) {\r\n                    return jqXHR;\r\n                }\r\n\r\n                // Timeout\r\n                if ( s.async && s.timeout > 0 ) {\r\n                    timeoutTimer = window.setTimeout( function() {\r\n                        jqXHR.abort( \"timeout\" );\r\n                    }, s.timeout );\r\n                }\r\n\r\n                try {\r\n                    completed = false;\r\n                    transport.send( requestHeaders, done );\r\n                } catch ( e ) {\r\n\r\n                    // Rethrow post-completion exceptions\r\n                    if ( completed ) {\r\n                        throw e;\r\n                    }\r\n\r\n                    // Propagate others as results\r\n                    done( -1, e );\r\n                }\r\n            }\r\n\r\n            // Callback for when everything is done\r\n            function done( status, nativeStatusText, responses, headers ) {\r\n                var isSuccess, success, error, response, modified,\r\n                    statusText = nativeStatusText;\r\n\r\n                // Ignore repeat invocations\r\n                if ( completed ) {\r\n                    return;\r\n                }\r\n\r\n                completed = true;\r\n\r\n                // Clear timeout if it exists\r\n                if ( timeoutTimer ) {\r\n                    window.clearTimeout( timeoutTimer );\r\n                }\r\n\r\n                // Dereference transport for early garbage collection\r\n                // (no matter how long the jqXHR object will be used)\r\n                transport = undefined;\r\n\r\n                // Cache response headers\r\n                responseHeadersString = headers || \"\";\r\n\r\n                // Set readyState\r\n                jqXHR.readyState = status > 0 ? 4 : 0;\r\n\r\n                // Determine if successful\r\n                isSuccess = status >= 200 && status < 300 || status === 304;\r\n\r\n                // Get response data\r\n                if ( responses ) {\r\n                    response = ajaxHandleResponses( s, jqXHR, responses );\r\n                }\r\n\r\n                // Use a noop converter for missing script but not if jsonp\r\n                if ( !isSuccess &&\r\n                    jQuery.inArray( \"script\", s.dataTypes ) > -1 &&\r\n                    jQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\r\n                    s.converters[ \"text script\" ] = function() {};\r\n                }\r\n\r\n                // Convert no matter what (that way responseXXX fields are always set)\r\n                response = ajaxConvert( s, response, jqXHR, isSuccess );\r\n\r\n                // If successful, handle type chaining\r\n                if ( isSuccess ) {\r\n\r\n                    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\r\n                    if ( s.ifModified ) {\r\n                        modified = jqXHR.getResponseHeader( \"Last-Modified\" );\r\n                        if ( modified ) {\r\n                            jQuery.lastModified[ cacheURL ] = modified;\r\n                        }\r\n                        modified = jqXHR.getResponseHeader( \"etag\" );\r\n                        if ( modified ) {\r\n                            jQuery.etag[ cacheURL ] = modified;\r\n                        }\r\n                    }\r\n\r\n                    // if no content\r\n                    if ( status === 204 || s.type === \"HEAD\" ) {\r\n                        statusText = \"nocontent\";\r\n\r\n                        // if not modified\r\n                    } else if ( status === 304 ) {\r\n                        statusText = \"notmodified\";\r\n\r\n                        // If we have data, let's convert it\r\n                    } else {\r\n                        statusText = response.state;\r\n                        success = response.data;\r\n                        error = response.error;\r\n                        isSuccess = !error;\r\n                    }\r\n                } else {\r\n\r\n                    // Extract error from statusText and normalize for non-aborts\r\n                    error = statusText;\r\n                    if ( status || !statusText ) {\r\n                        statusText = \"error\";\r\n                        if ( status < 0 ) {\r\n                            status = 0;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // Set data for the fake xhr object\r\n                jqXHR.status = status;\r\n                jqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\r\n\r\n                // Success/Error\r\n                if ( isSuccess ) {\r\n                    deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\r\n                } else {\r\n                    deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\r\n                }\r\n\r\n                // Status-dependent callbacks\r\n                jqXHR.statusCode( statusCode );\r\n                statusCode = undefined;\r\n\r\n                if ( fireGlobals ) {\r\n                    globalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\r\n                        [ jqXHR, s, isSuccess ? success : error ] );\r\n                }\r\n\r\n                // Complete\r\n                completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\r\n\r\n                if ( fireGlobals ) {\r\n                    globalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\r\n\r\n                    // Handle the global AJAX counter\r\n                    if ( !( --jQuery.active ) ) {\r\n                        jQuery.event.trigger( \"ajaxStop\" );\r\n                    }\r\n                }\r\n            }\r\n\r\n            return jqXHR;\r\n        },\r\n\r\n        getJSON: function( url, data, callback ) {\r\n            return jQuery.get( url, data, callback, \"json\" );\r\n        },\r\n\r\n        getScript: function( url, callback ) {\r\n            return jQuery.get( url, undefined, callback, \"script\" );\r\n        }\r\n    } );\r\n\r\n    jQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\r\n        jQuery[ method ] = function( url, data, callback, type ) {\r\n\r\n            // Shift arguments if data argument was omitted\r\n            if ( isFunction( data ) ) {\r\n                type = type || callback;\r\n                callback = data;\r\n                data = undefined;\r\n            }\r\n\r\n            // The url can be an options object (which then must have .url)\r\n            return jQuery.ajax( jQuery.extend( {\r\n                url: url,\r\n                type: method,\r\n                dataType: type,\r\n                data: data,\r\n                success: callback\r\n            }, jQuery.isPlainObject( url ) && url ) );\r\n        };\r\n    } );\r\n\r\n    jQuery.ajaxPrefilter( function( s ) {\r\n        var i;\r\n        for ( i in s.headers ) {\r\n            if ( i.toLowerCase() === \"content-type\" ) {\r\n                s.contentType = s.headers[ i ] || \"\";\r\n            }\r\n        }\r\n    } );\r\n\r\n\r\n    jQuery._evalUrl = function( url, options, doc ) {\r\n        return jQuery.ajax( {\r\n            url: url,\r\n\r\n            // Make this explicit, since user can override this through ajaxSetup (#11264)\r\n            type: \"GET\",\r\n            dataType: \"script\",\r\n            cache: true,\r\n            async: false,\r\n            global: false,\r\n\r\n            // Only evaluate the response if it is successful (gh-4126)\r\n            // dataFilter is not invoked for failure responses, so using it instead\r\n            // of the default converter is kludgy but it works.\r\n            converters: {\r\n                \"text script\": function() {}\r\n            },\r\n            dataFilter: function( response ) {\r\n                jQuery.globalEval( response, options, doc );\r\n            }\r\n        } );\r\n    };\r\n\r\n\r\n    jQuery.fn.extend( {\r\n        wrapAll: function( html ) {\r\n            var wrap;\r\n\r\n            if ( this[ 0 ] ) {\r\n                if ( isFunction( html ) ) {\r\n                    html = html.call( this[ 0 ] );\r\n                }\r\n\r\n                // The elements to wrap the target around\r\n                wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\r\n\r\n                if ( this[ 0 ].parentNode ) {\r\n                    wrap.insertBefore( this[ 0 ] );\r\n                }\r\n\r\n                wrap.map( function() {\r\n                    var elem = this;\r\n\r\n                    while ( elem.firstElementChild ) {\r\n                        elem = elem.firstElementChild;\r\n                    }\r\n\r\n                    return elem;\r\n                } ).append( this );\r\n            }\r\n\r\n            return this;\r\n        },\r\n\r\n        wrapInner: function( html ) {\r\n            if ( isFunction( html ) ) {\r\n                return this.each( function( i ) {\r\n                    jQuery( this ).wrapInner( html.call( this, i ) );\r\n                } );\r\n            }\r\n\r\n            return this.each( function() {\r\n                var self = jQuery( this ),\r\n                    contents = self.contents();\r\n\r\n                if ( contents.length ) {\r\n                    contents.wrapAll( html );\r\n\r\n                } else {\r\n                    self.append( html );\r\n                }\r\n            } );\r\n        },\r\n\r\n        wrap: function( html ) {\r\n            var htmlIsFunction = isFunction( html );\r\n\r\n            return this.each( function( i ) {\r\n                jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\r\n            } );\r\n        },\r\n\r\n        unwrap: function( selector ) {\r\n            this.parent( selector ).not( \"body\" ).each( function() {\r\n                jQuery( this ).replaceWith( this.childNodes );\r\n            } );\r\n            return this;\r\n        }\r\n    } );\r\n\r\n\r\n    jQuery.expr.pseudos.hidden = function( elem ) {\r\n        return !jQuery.expr.pseudos.visible( elem );\r\n    };\r\n    jQuery.expr.pseudos.visible = function( elem ) {\r\n        return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\r\n    };\r\n\r\n\r\n\r\n\r\n    jQuery.ajaxSettings.xhr = function() {\r\n        try {\r\n            return new window.XMLHttpRequest();\r\n        } catch ( e ) {}\r\n    };\r\n\r\n    var xhrSuccessStatus = {\r\n\r\n            // File protocol always yields status code 0, assume 200\r\n            0: 200,\r\n\r\n            // Support: IE <=9 only\r\n            // #1450: sometimes IE returns 1223 when it should be 204\r\n            1223: 204\r\n        },\r\n        xhrSupported = jQuery.ajaxSettings.xhr();\r\n\r\n    support.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\r\n    support.ajax = xhrSupported = !!xhrSupported;\r\n\r\n    jQuery.ajaxTransport( function( options ) {\r\n        var callback, errorCallback;\r\n\r\n        // Cross domain only allowed if supported through XMLHttpRequest\r\n        if ( support.cors || xhrSupported && !options.crossDomain ) {\r\n            return {\r\n                send: function( headers, complete ) {\r\n                    var i,\r\n                        xhr = options.xhr();\r\n\r\n                    xhr.open(\r\n                        options.type,\r\n                        options.url,\r\n                        options.async,\r\n                        options.username,\r\n                        options.password\r\n                    );\r\n\r\n                    // Apply custom fields if provided\r\n                    if ( options.xhrFields ) {\r\n                        for ( i in options.xhrFields ) {\r\n                            xhr[ i ] = options.xhrFields[ i ];\r\n                        }\r\n                    }\r\n\r\n                    // Override mime type if needed\r\n                    if ( options.mimeType && xhr.overrideMimeType ) {\r\n                        xhr.overrideMimeType( options.mimeType );\r\n                    }\r\n\r\n                    // X-Requested-With header\r\n                    // For cross-domain requests, seeing as conditions for a preflight are\r\n                    // akin to a jigsaw puzzle, we simply never set it to be sure.\r\n                    // (it can always be set on a per-request basis or even using ajaxSetup)\r\n                    // For same-domain requests, won't change header if already provided.\r\n                    if ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\r\n                        headers[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\r\n                    }\r\n\r\n                    // Set headers\r\n                    for ( i in headers ) {\r\n                        xhr.setRequestHeader( i, headers[ i ] );\r\n                    }\r\n\r\n                    // Callback\r\n                    callback = function( type ) {\r\n                        return function() {\r\n                            if ( callback ) {\r\n                                callback = errorCallback = xhr.onload =\r\n                                    xhr.onerror = xhr.onabort = xhr.ontimeout =\r\n                                        xhr.onreadystatechange = null;\r\n\r\n                                if ( type === \"abort\" ) {\r\n                                    xhr.abort();\r\n                                } else if ( type === \"error\" ) {\r\n\r\n                                    // Support: IE <=9 only\r\n                                    // On a manual native abort, IE9 throws\r\n                                    // errors on any property access that is not readyState\r\n                                    if ( typeof xhr.status !== \"number\" ) {\r\n                                        complete( 0, \"error\" );\r\n                                    } else {\r\n                                        complete(\r\n\r\n                                            // File: protocol always yields status 0; see #8605, #14207\r\n                                            xhr.status,\r\n                                            xhr.statusText\r\n                                        );\r\n                                    }\r\n                                } else {\r\n                                    complete(\r\n                                        xhrSuccessStatus[ xhr.status ] || xhr.status,\r\n                                        xhr.statusText,\r\n\r\n                                        // Support: IE <=9 only\r\n                                        // IE9 has no XHR2 but throws on binary (trac-11426)\r\n                                        // For XHR2 non-text, let the caller handle it (gh-2498)\r\n                                        ( xhr.responseType || \"text\" ) !== \"text\"  ||\r\n                                        typeof xhr.responseText !== \"string\" ?\r\n                                            { binary: xhr.response } :\r\n                                            { text: xhr.responseText },\r\n                                        xhr.getAllResponseHeaders()\r\n                                    );\r\n                                }\r\n                            }\r\n                        };\r\n                    };\r\n\r\n                    // Listen to events\r\n                    xhr.onload = callback();\r\n                    errorCallback = xhr.onerror = xhr.ontimeout = callback( \"error\" );\r\n\r\n                    // Support: IE 9 only\r\n                    // Use onreadystatechange to replace onabort\r\n                    // to handle uncaught aborts\r\n                    if ( xhr.onabort !== undefined ) {\r\n                        xhr.onabort = errorCallback;\r\n                    } else {\r\n                        xhr.onreadystatechange = function() {\r\n\r\n                            // Check readyState before timeout as it changes\r\n                            if ( xhr.readyState === 4 ) {\r\n\r\n                                // Allow onerror to be called first,\r\n                                // but that will not handle a native abort\r\n                                // Also, save errorCallback to a variable\r\n                                // as xhr.onerror cannot be accessed\r\n                                window.setTimeout( function() {\r\n                                    if ( callback ) {\r\n                                        errorCallback();\r\n                                    }\r\n                                } );\r\n                            }\r\n                        };\r\n                    }\r\n\r\n                    // Create the abort callback\r\n                    callback = callback( \"abort\" );\r\n\r\n                    try {\r\n\r\n                        // Do send the request (this may raise an exception)\r\n                        xhr.send( options.hasContent && options.data || null );\r\n                    } catch ( e ) {\r\n\r\n                        // #14683: Only rethrow if this hasn't been notified as an error yet\r\n                        if ( callback ) {\r\n                            throw e;\r\n                        }\r\n                    }\r\n                },\r\n\r\n                abort: function() {\r\n                    if ( callback ) {\r\n                        callback();\r\n                    }\r\n                }\r\n            };\r\n        }\r\n    } );\r\n\r\n\r\n\r\n\r\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\r\n    jQuery.ajaxPrefilter( function( s ) {\r\n        if ( s.crossDomain ) {\r\n            s.contents.script = false;\r\n        }\r\n    } );\r\n\r\n// Install script dataType\r\n    jQuery.ajaxSetup( {\r\n        accepts: {\r\n            script: \"text/javascript, application/javascript, \" +\r\n                \"application/ecmascript, application/x-ecmascript\"\r\n        },\r\n        contents: {\r\n            script: /\\b(?:java|ecma)script\\b/\r\n        },\r\n        converters: {\r\n            \"text script\": function( text ) {\r\n                jQuery.globalEval( text );\r\n                return text;\r\n            }\r\n        }\r\n    } );\r\n\r\n// Handle cache's special case and crossDomain\r\n    jQuery.ajaxPrefilter( \"script\", function( s ) {\r\n        if ( s.cache === undefined ) {\r\n            s.cache = false;\r\n        }\r\n        if ( s.crossDomain ) {\r\n            s.type = \"GET\";\r\n        }\r\n    } );\r\n\r\n// Bind script tag hack transport\r\n    jQuery.ajaxTransport( \"script\", function( s ) {\r\n\r\n        // This transport only deals with cross domain or forced-by-attrs requests\r\n        if ( s.crossDomain || s.scriptAttrs ) {\r\n            var script, callback;\r\n            return {\r\n                send: function( _, complete ) {\r\n                    script = jQuery( \"<script>\" )\r\n                        .attr( s.scriptAttrs || {} )\r\n                        .prop( { charset: s.scriptCharset, src: s.url } )\r\n                        .on( \"load error\", callback = function( evt ) {\r\n                            script.remove();\r\n                            callback = null;\r\n                            if ( evt ) {\r\n                                complete( evt.type === \"error\" ? 404 : 200, evt.type );\r\n                            }\r\n                        } );\r\n\r\n                    // Use native DOM manipulation to avoid our domManip AJAX trickery\r\n                    document.head.appendChild( script[ 0 ] );\r\n                },\r\n                abort: function() {\r\n                    if ( callback ) {\r\n                        callback();\r\n                    }\r\n                }\r\n            };\r\n        }\r\n    } );\r\n\r\n\r\n\r\n\r\n    var oldCallbacks = [],\r\n        rjsonp = /(=)\\?(?=&|$)|\\?\\?/;\r\n\r\n// Default jsonp settings\r\n    jQuery.ajaxSetup( {\r\n        jsonp: \"callback\",\r\n        jsonpCallback: function() {\r\n            var callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce.guid++ ) );\r\n            this[ callback ] = true;\r\n            return callback;\r\n        }\r\n    } );\r\n\r\n// Detect, normalize options and install callbacks for jsonp requests\r\n    jQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\r\n\r\n        var callbackName, overwritten, responseContainer,\r\n            jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\r\n                    \"url\" :\r\n                    typeof s.data === \"string\" &&\r\n                    ( s.contentType || \"\" )\r\n                        .indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\r\n                    rjsonp.test( s.data ) && \"data\"\r\n            );\r\n\r\n        // Handle iff the expected data type is \"jsonp\" or we have a parameter to set\r\n        if ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\r\n\r\n            // Get callback name, remembering preexisting value associated with it\r\n            callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?\r\n                s.jsonpCallback() :\r\n                s.jsonpCallback;\r\n\r\n            // Insert callback into url or form data\r\n            if ( jsonProp ) {\r\n                s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\r\n            } else if ( s.jsonp !== false ) {\r\n                s.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\r\n            }\r\n\r\n            // Use data converter to retrieve json after script execution\r\n            s.converters[ \"script json\" ] = function() {\r\n                if ( !responseContainer ) {\r\n                    jQuery.error( callbackName + \" was not called\" );\r\n                }\r\n                return responseContainer[ 0 ];\r\n            };\r\n\r\n            // Force json dataType\r\n            s.dataTypes[ 0 ] = \"json\";\r\n\r\n            // Install callback\r\n            overwritten = window[ callbackName ];\r\n            window[ callbackName ] = function() {\r\n                responseContainer = arguments;\r\n            };\r\n\r\n            // Clean-up function (fires after converters)\r\n            jqXHR.always( function() {\r\n\r\n                // If previous value didn't exist - remove it\r\n                if ( overwritten === undefined ) {\r\n                    jQuery( window ).removeProp( callbackName );\r\n\r\n                    // Otherwise restore preexisting value\r\n                } else {\r\n                    window[ callbackName ] = overwritten;\r\n                }\r\n\r\n                // Save back as free\r\n                if ( s[ callbackName ] ) {\r\n\r\n                    // Make sure that re-using the options doesn't screw things around\r\n                    s.jsonpCallback = originalSettings.jsonpCallback;\r\n\r\n                    // Save the callback name for future use\r\n                    oldCallbacks.push( callbackName );\r\n                }\r\n\r\n                // Call if it was a function and we have a response\r\n                if ( responseContainer && isFunction( overwritten ) ) {\r\n                    overwritten( responseContainer[ 0 ] );\r\n                }\r\n\r\n                responseContainer = overwritten = undefined;\r\n            } );\r\n\r\n            // Delegate to script\r\n            return \"script\";\r\n        }\r\n    } );\r\n\r\n\r\n\r\n\r\n// Support: Safari 8 only\r\n// In Safari 8 documents created via document.implementation.createHTMLDocument\r\n// collapse sibling forms: the second one becomes a child of the first one.\r\n// Because of that, this security measure has to be disabled in Safari 8.\r\n// https://bugs.webkit.org/show_bug.cgi?id=137337\r\n    support.createHTMLDocument = ( function() {\r\n        var body = document.implementation.createHTMLDocument( \"\" ).body;\r\n        body.innerHTML = \"<form></form><form></form>\";\r\n        return body.childNodes.length === 2;\r\n    } )();\r\n\r\n\r\n// Argument \"data\" should be string of html\r\n// context (optional): If specified, the fragment will be created in this context,\r\n// defaults to document\r\n// keepScripts (optional): If true, will include scripts passed in the html string\r\n    jQuery.parseHTML = function( data, context, keepScripts ) {\r\n        if ( typeof data !== \"string\" ) {\r\n            return [];\r\n        }\r\n        if ( typeof context === \"boolean\" ) {\r\n            keepScripts = context;\r\n            context = false;\r\n        }\r\n\r\n        var base, parsed, scripts;\r\n\r\n        if ( !context ) {\r\n\r\n            // Stop scripts or inline event handlers from being executed immediately\r\n            // by using document.implementation\r\n            if ( support.createHTMLDocument ) {\r\n                context = document.implementation.createHTMLDocument( \"\" );\r\n\r\n                // Set the base href for the created document\r\n                // so any parsed elements with URLs\r\n                // are based on the document's URL (gh-2965)\r\n                base = context.createElement( \"base\" );\r\n                base.href = document.location.href;\r\n                context.head.appendChild( base );\r\n            } else {\r\n                context = document;\r\n            }\r\n        }\r\n\r\n        parsed = rsingleTag.exec( data );\r\n        scripts = !keepScripts && [];\r\n\r\n        // Single tag\r\n        if ( parsed ) {\r\n            return [ context.createElement( parsed[ 1 ] ) ];\r\n        }\r\n\r\n        parsed = buildFragment( [ data ], context, scripts );\r\n\r\n        if ( scripts && scripts.length ) {\r\n            jQuery( scripts ).remove();\r\n        }\r\n\r\n        return jQuery.merge( [], parsed.childNodes );\r\n    };\r\n\r\n\r\n    /**\r\n     * Load a url into a page\r\n     */\r\n    jQuery.fn.load = function( url, params, callback ) {\r\n        var selector, type, response,\r\n            self = this,\r\n            off = url.indexOf( \" \" );\r\n\r\n        if ( off > -1 ) {\r\n            selector = stripAndCollapse( url.slice( off ) );\r\n            url = url.slice( 0, off );\r\n        }\r\n\r\n        // If it's a function\r\n        if ( isFunction( params ) ) {\r\n\r\n            // We assume that it's the callback\r\n            callback = params;\r\n            params = undefined;\r\n\r\n            // Otherwise, build a param string\r\n        } else if ( params && typeof params === \"object\" ) {\r\n            type = \"POST\";\r\n        }\r\n\r\n        // If we have elements to modify, make the request\r\n        if ( self.length > 0 ) {\r\n            jQuery.ajax( {\r\n                url: url,\r\n\r\n                // If \"type\" variable is undefined, then \"GET\" method will be used.\r\n                // Make value of this field explicit since\r\n                // user can override it through ajaxSetup method\r\n                type: type || \"GET\",\r\n                dataType: \"html\",\r\n                data: params\r\n            } ).done( function( responseText ) {\r\n\r\n                // Save response for use in complete callback\r\n                response = arguments;\r\n\r\n                self.html( selector ?\r\n\r\n                    // If a selector was specified, locate the right elements in a dummy div\r\n                    // Exclude scripts to avoid IE 'Permission Denied' errors\r\n                    jQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\r\n\r\n                    // Otherwise use the full result\r\n                    responseText );\r\n\r\n                // If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\r\n                // but they are ignored because response was set above.\r\n                // If it fails, this function gets \"jqXHR\", \"status\", \"error\"\r\n            } ).always( callback && function( jqXHR, status ) {\r\n                self.each( function() {\r\n                    callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\r\n                } );\r\n            } );\r\n        }\r\n\r\n        return this;\r\n    };\r\n\r\n\r\n\r\n\r\n    jQuery.expr.pseudos.animated = function( elem ) {\r\n        return jQuery.grep( jQuery.timers, function( fn ) {\r\n            return elem === fn.elem;\r\n        } ).length;\r\n    };\r\n\r\n\r\n\r\n\r\n    jQuery.offset = {\r\n        setOffset: function( elem, options, i ) {\r\n            var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\r\n                position = jQuery.css( elem, \"position\" ),\r\n                curElem = jQuery( elem ),\r\n                props = {};\r\n\r\n            // Set position first, in-case top/left are set even on static elem\r\n            if ( position === \"static\" ) {\r\n                elem.style.position = \"relative\";\r\n            }\r\n\r\n            curOffset = curElem.offset();\r\n            curCSSTop = jQuery.css( elem, \"top\" );\r\n            curCSSLeft = jQuery.css( elem, \"left\" );\r\n            calculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\r\n                ( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\r\n\r\n            // Need to be able to calculate position if either\r\n            // top or left is auto and position is either absolute or fixed\r\n            if ( calculatePosition ) {\r\n                curPosition = curElem.position();\r\n                curTop = curPosition.top;\r\n                curLeft = curPosition.left;\r\n\r\n            } else {\r\n                curTop = parseFloat( curCSSTop ) || 0;\r\n                curLeft = parseFloat( curCSSLeft ) || 0;\r\n            }\r\n\r\n            if ( isFunction( options ) ) {\r\n\r\n                // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\r\n                options = options.call( elem, i, jQuery.extend( {}, curOffset ) );\r\n            }\r\n\r\n            if ( options.top != null ) {\r\n                props.top = ( options.top - curOffset.top ) + curTop;\r\n            }\r\n            if ( options.left != null ) {\r\n                props.left = ( options.left - curOffset.left ) + curLeft;\r\n            }\r\n\r\n            if ( \"using\" in options ) {\r\n                options.using.call( elem, props );\r\n\r\n            } else {\r\n                curElem.css( props );\r\n            }\r\n        }\r\n    };\r\n\r\n    jQuery.fn.extend( {\r\n\r\n        // offset() relates an element's border box to the document origin\r\n        offset: function( options ) {\r\n\r\n            // Preserve chaining for setter\r\n            if ( arguments.length ) {\r\n                return options === undefined ?\r\n                    this :\r\n                    this.each( function( i ) {\r\n                        jQuery.offset.setOffset( this, options, i );\r\n                    } );\r\n            }\r\n\r\n            var rect, win,\r\n                elem = this[ 0 ];\r\n\r\n            if ( !elem ) {\r\n                return;\r\n            }\r\n\r\n            // Return zeros for disconnected and hidden (display: none) elements (gh-2310)\r\n            // Support: IE <=11 only\r\n            // Running getBoundingClientRect on a\r\n            // disconnected node in IE throws an error\r\n            if ( !elem.getClientRects().length ) {\r\n                return { top: 0, left: 0 };\r\n            }\r\n\r\n            // Get document-relative position by adding viewport scroll to viewport-relative gBCR\r\n            rect = elem.getBoundingClientRect();\r\n            win = elem.ownerDocument.defaultView;\r\n            return {\r\n                top: rect.top + win.pageYOffset,\r\n                left: rect.left + win.pageXOffset\r\n            };\r\n        },\r\n\r\n        // position() relates an element's margin box to its offset parent's padding box\r\n        // This corresponds to the behavior of CSS absolute positioning\r\n        position: function() {\r\n            if ( !this[ 0 ] ) {\r\n                return;\r\n            }\r\n\r\n            var offsetParent, offset, doc,\r\n                elem = this[ 0 ],\r\n                parentOffset = { top: 0, left: 0 };\r\n\r\n            // position:fixed elements are offset from the viewport, which itself always has zero offset\r\n            if ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\r\n\r\n                // Assume position:fixed implies availability of getBoundingClientRect\r\n                offset = elem.getBoundingClientRect();\r\n\r\n            } else {\r\n                offset = this.offset();\r\n\r\n                // Account for the *real* offset parent, which can be the document or its root element\r\n                // when a statically positioned element is identified\r\n                doc = elem.ownerDocument;\r\n                offsetParent = elem.offsetParent || doc.documentElement;\r\n                while ( offsetParent &&\r\n                ( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\r\n                jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\r\n\r\n                    offsetParent = offsetParent.parentNode;\r\n                }\r\n                if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\r\n\r\n                    // Incorporate borders into its offset, since they are outside its content origin\r\n                    parentOffset = jQuery( offsetParent ).offset();\r\n                    parentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\r\n                    parentOffset.left += jQuery.css( offsetParent, \"borderLeftWidth\", true );\r\n                }\r\n            }\r\n\r\n            // Subtract parent offsets and element margins\r\n            return {\r\n                top: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\r\n                left: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\r\n            };\r\n        },\r\n\r\n        // This method will return documentElement in the following cases:\r\n        // 1) For the element inside the iframe without offsetParent, this method will return\r\n        //    documentElement of the parent window\r\n        // 2) For the hidden or detached element\r\n        // 3) For body or html element, i.e. in case of the html node - it will return itself\r\n        //\r\n        // but those exceptions were never presented as a real life use-cases\r\n        // and might be considered as more preferable results.\r\n        //\r\n        // This logic, however, is not guaranteed and can change at any point in the future\r\n        offsetParent: function() {\r\n            return this.map( function() {\r\n                var offsetParent = this.offsetParent;\r\n\r\n                while ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\r\n                    offsetParent = offsetParent.offsetParent;\r\n                }\r\n\r\n                return offsetParent || documentElement;\r\n            } );\r\n        }\r\n    } );\r\n\r\n// Create scrollLeft and scrollTop methods\r\n    jQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\r\n        var top = \"pageYOffset\" === prop;\r\n\r\n        jQuery.fn[ method ] = function( val ) {\r\n            return access( this, function( elem, method, val ) {\r\n\r\n                // Coalesce documents and windows\r\n                var win;\r\n                if ( isWindow( elem ) ) {\r\n                    win = elem;\r\n                } else if ( elem.nodeType === 9 ) {\r\n                    win = elem.defaultView;\r\n                }\r\n\r\n                if ( val === undefined ) {\r\n                    return win ? win[ prop ] : elem[ method ];\r\n                }\r\n\r\n                if ( win ) {\r\n                    win.scrollTo(\r\n                        !top ? val : win.pageXOffset,\r\n                        top ? val : win.pageYOffset\r\n                    );\r\n\r\n                } else {\r\n                    elem[ method ] = val;\r\n                }\r\n            }, method, val, arguments.length );\r\n        };\r\n    } );\r\n\r\n// Support: Safari <=7 - 9.1, Chrome <=37 - 49\r\n// Add the top/left cssHooks using jQuery.fn.position\r\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\r\n// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\r\n// getComputedStyle returns percent when specified for top/left/bottom/right;\r\n// rather than make the css module depend on the offset module, just check for it here\r\n    jQuery.each( [ \"top\", \"left\" ], function( _i, prop ) {\r\n        jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\r\n            function( elem, computed ) {\r\n                if ( computed ) {\r\n                    computed = curCSS( elem, prop );\r\n\r\n                    // If curCSS returns percentage, fallback to offset\r\n                    return rnumnonpx.test( computed ) ?\r\n                        jQuery( elem ).position()[ prop ] + \"px\" :\r\n                        computed;\r\n                }\r\n            }\r\n        );\r\n    } );\r\n\r\n\r\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\r\n    jQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\r\n        jQuery.each( {\r\n            padding: \"inner\" + name,\r\n            content: type,\r\n            \"\": \"outer\" + name\r\n        }, function( defaultExtra, funcName ) {\r\n\r\n            // Margin is only for outerHeight, outerWidth\r\n            jQuery.fn[ funcName ] = function( margin, value ) {\r\n                var chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\r\n                    extra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\r\n\r\n                return access( this, function( elem, type, value ) {\r\n                    var doc;\r\n\r\n                    if ( isWindow( elem ) ) {\r\n\r\n                        // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\r\n                        return funcName.indexOf( \"outer\" ) === 0 ?\r\n                            elem[ \"inner\" + name ] :\r\n                            elem.document.documentElement[ \"client\" + name ];\r\n                    }\r\n\r\n                    // Get document width or height\r\n                    if ( elem.nodeType === 9 ) {\r\n                        doc = elem.documentElement;\r\n\r\n                        // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\r\n                        // whichever is greatest\r\n                        return Math.max(\r\n                            elem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\r\n                            elem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\r\n                            doc[ \"client\" + name ]\r\n                        );\r\n                    }\r\n\r\n                    return value === undefined ?\r\n\r\n                        // Get width or height on the element, requesting but not forcing parseFloat\r\n                        jQuery.css( elem, type, extra ) :\r\n\r\n                        // Set width or height on the element\r\n                        jQuery.style( elem, type, value, extra );\r\n                }, type, chainable ? margin : undefined, chainable );\r\n            };\r\n        } );\r\n    } );\r\n\r\n\r\n    jQuery.each( [\r\n        \"ajaxStart\",\r\n        \"ajaxStop\",\r\n        \"ajaxComplete\",\r\n        \"ajaxError\",\r\n        \"ajaxSuccess\",\r\n        \"ajaxSend\"\r\n    ], function( _i, type ) {\r\n        jQuery.fn[ type ] = function( fn ) {\r\n            return this.on( type, fn );\r\n        };\r\n    } );\r\n\r\n\r\n\r\n\r\n    jQuery.fn.extend( {\r\n\r\n        bind: function( types, data, fn ) {\r\n            return this.on( types, null, data, fn );\r\n        },\r\n        unbind: function( types, fn ) {\r\n            return this.off( types, null, fn );\r\n        },\r\n\r\n        delegate: function( selector, types, data, fn ) {\r\n            return this.on( types, selector, data, fn );\r\n        },\r\n        undelegate: function( selector, types, fn ) {\r\n\r\n            // ( namespace ) or ( selector, types [, fn] )\r\n            return arguments.length === 1 ?\r\n                this.off( selector, \"**\" ) :\r\n                this.off( types, selector || \"**\", fn );\r\n        },\r\n\r\n        hover: function( fnOver, fnOut ) {\r\n            return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\r\n        }\r\n    } );\r\n\r\n    jQuery.each(\r\n        ( \"blur focus focusin focusout resize scroll click dblclick \" +\r\n            \"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\r\n            \"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\r\n        function( _i, name ) {\r\n\r\n            // Handle event binding\r\n            jQuery.fn[ name ] = function( data, fn ) {\r\n                return arguments.length > 0 ?\r\n                    this.on( name, null, data, fn ) :\r\n                    this.trigger( name );\r\n            };\r\n        }\r\n    );\r\n\r\n\r\n\r\n\r\n// Support: Android <=4.0 only\r\n// Make sure we trim BOM and NBSP\r\n    var rtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;\r\n\r\n// Bind a function to a context, optionally partially applying any\r\n// arguments.\r\n// jQuery.proxy is deprecated to promote standards (specifically Function#bind)\r\n// However, it is not slated for removal any time soon\r\n    jQuery.proxy = function( fn, context ) {\r\n        var tmp, args, proxy;\r\n\r\n        if ( typeof context === \"string\" ) {\r\n            tmp = fn[ context ];\r\n            context = fn;\r\n            fn = tmp;\r\n        }\r\n\r\n        // Quick check to determine if target is callable, in the spec\r\n        // this throws a TypeError, but we will just return undefined.\r\n        if ( !isFunction( fn ) ) {\r\n            return undefined;\r\n        }\r\n\r\n        // Simulated bind\r\n        args = slice.call( arguments, 2 );\r\n        proxy = function() {\r\n            return fn.apply( context || this, args.concat( slice.call( arguments ) ) );\r\n        };\r\n\r\n        // Set the guid of unique handler to the same of original handler, so it can be removed\r\n        proxy.guid = fn.guid = fn.guid || jQuery.guid++;\r\n\r\n        return proxy;\r\n    };\r\n\r\n    jQuery.holdReady = function( hold ) {\r\n        if ( hold ) {\r\n            jQuery.readyWait++;\r\n        } else {\r\n            jQuery.ready( true );\r\n        }\r\n    };\r\n    jQuery.isArray = Array.isArray;\r\n    jQuery.parseJSON = JSON.parse;\r\n    jQuery.nodeName = nodeName;\r\n    jQuery.isFunction = isFunction;\r\n    jQuery.isWindow = isWindow;\r\n    jQuery.camelCase = camelCase;\r\n    jQuery.type = toType;\r\n\r\n    jQuery.now = Date.now;\r\n\r\n    jQuery.isNumeric = function( obj ) {\r\n\r\n        // As of jQuery 3.0, isNumeric is limited to\r\n        // strings and numbers (primitives or objects)\r\n        // that can be coerced to finite numbers (gh-2662)\r\n        var type = jQuery.type( obj );\r\n        return ( type === \"number\" || type === \"string\" ) &&\r\n\r\n            // parseFloat NaNs numeric-cast false positives (\"\")\r\n            // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\r\n            // subtraction forces infinities to NaN\r\n            !isNaN( obj - parseFloat( obj ) );\r\n    };\r\n\r\n    jQuery.trim = function( text ) {\r\n        return text == null ?\r\n            \"\" :\r\n            ( text + \"\" ).replace( rtrim, \"\" );\r\n    };\r\n\r\n\r\n\r\n// Register as a named AMD module, since jQuery can be concatenated with other\r\n// files that may use define, but not via a proper concatenation script that\r\n// understands anonymous AMD modules. A named AMD is safest and most robust\r\n// way to register. Lowercase jquery is used because AMD module names are\r\n// derived from file names, and jQuery is normally delivered in a lowercase\r\n// file name. Do this after creating the global so that if an AMD module wants\r\n// to call noConflict to hide this version of jQuery, it will work.\r\n\r\n// Note that for maximum portability, libraries that are not jQuery should\r\n// declare themselves as anonymous modules, and avoid setting a global if an\r\n// AMD loader is present. jQuery is a special case. For more information, see\r\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\r\n\r\n    if ( typeof define === \"function\" && define.amd ) {\r\n        define( \"jquery\", [], function() {\r\n            return jQuery;\r\n        } );\r\n    }\r\n\r\n\r\n\r\n\r\n    var\r\n\r\n        // Map over jQuery in case of overwrite\r\n        _jQuery = window.jQuery,\r\n\r\n        // Map over the $ in case of overwrite\r\n        _$ = window.$;\r\n\r\n    jQuery.noConflict = function( deep ) {\r\n        if ( window.$ === jQuery ) {\r\n            window.$ = _$;\r\n        }\r\n\r\n        if ( deep && window.jQuery === jQuery ) {\r\n            window.jQuery = _jQuery;\r\n        }\r\n\r\n        return jQuery;\r\n    };\r\n\r\n// Expose jQuery and $ identifiers, even in AMD\r\n// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\r\n// and CommonJS for browser emulators (#13566)\r\n    if ( typeof noGlobal === \"undefined\" ) {\r\n        window.jQuery = window.$ = jQuery;\r\n    }\r\n\r\n\r\n\r\n\r\n    return jQuery;\r\n} );\r\n","const CDP = require(\"./scan.foundation.cdp\").default;\r\nmodule.exports = CDP;\r\n","/*\r\nSitecore CDP frontend JavaScript integration with backend WebAPIs\r\n*/\r\n\r\nexport default class {\r\n    static getBrowserId() {\r\n        var url = \"/api/event/getBrowserId\";\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n\r\n    static createIdentityEvent(browserId, pageUrl, id, email, firstname, lastname) {\r\n        var url = \"/api/event/createIdentity?browserId=\" + browserId + \"&pageUrl=\" + pageUrl + \"&id=\" + id + \"&email=\" + email + \"&firstname=\" + firstname + \"&lastname=\" + lastname;\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n\r\n    static createAddCartEvent(browserId, pageUrl, referenceId, type, name, productId, item_id) {\r\n        var url = \"/api/event/createAddCart?browserId=\" + browserId + \"&pageUrl=\" + pageUrl + \"&referenceId=\" + referenceId + \"&type=\" + type + \"&name=\" + name + \"&productId=\" + productId + \"&item_id=\" + item_id;\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n\r\n    static deleteGuest(guestRef) {\r\n        var url = \"/api/guest/delete?guestRef=\" + guestRef;\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n\r\n    static retrieveGuest(email) {\r\n        let url = \"/api/guest/retrieve?email=\" + email;\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n\r\n    static updateGuest(guestRef, city, state, country, gender) {\r\n        var url = \"/api/guest/update?guestRef=\" + guestRef + \"&city=\" + city + \"&state=\" + state + \"&country=\" + country + \"&gender=\" + gender;\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n\r\n    static saveGuestData(guestRef, language, planName, state, county, lastStep) {\r\n        var url = \"/api/guest/savedata?guestRef=\" + guestRef + \"&language=\" + language + \"&planName=\" + planName + \"&state=\" + state + \"&county=\" + county + \"&lastStep=\" + lastStep;\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n\r\n    static trackMeta(browserId, eventName) {\r\n        var url = \"/api/meta/track?browserId=\" + browserId + \"&eventName=\" + eventName + \"&url=\" + window.location.pathname;\r\n\r\n        return new Promise((resolve, reject) => (fetch(url, {\r\n            method: 'get',\r\n            headers: {\r\n                'Accept': 'application/json',\r\n                'Content-Type': 'application/json'\r\n            }\r\n        }).then(response => {\r\n            return resolve(response.json());\r\n        }).catch((error) => {\r\n            console.log(error);\r\n            return reject(error);\r\n        })));\r\n    }\r\n}\r\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// startup\n// Load entry module and return exports\n// This entry module used 'module' so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(5002);\n"],"names":["define","CDP","$","window","setTimeout","console","log","Date","getBrowserId","then","data","browserId","on","trackMeta","global","factory","module","exports","document","w","Error","this","noGlobal","arr","getProto","Object","getPrototypeOf","slice","flat","array","call","concat","apply","push","indexOf","class2type","toString","hasOwn","hasOwnProperty","fnToString","ObjectFunctionString","support","isFunction","obj","nodeType","item","isWindow","preservedScriptAttributes","type","src","nonce","noModule","DOMEval","code","node","doc","i","val","script","createElement","text","getAttribute","setAttribute","head","appendChild","parentNode","removeChild","toType","version","jQuery","selector","context","fn","init","isArrayLike","length","prototype","jquery","constructor","toArray","get","num","pushStack","elems","ret","merge","prevObject","each","callback","map","elem","arguments","first","eq","last","even","grep","_elem","odd","len","j","end","sort","splice","extend","options","name","copy","copyIsArray","clone","target","deep","isPlainObject","Array","isArray","undefined","expando","Math","random","replace","isReady","error","msg","noop","proto","Ctor","isEmptyObject","globalEval","makeArray","results","inArray","second","invert","matches","callbackExpect","arg","value","guid","Symbol","iterator","split","_i","toLowerCase","Sizzle","Expr","getText","isXML","tokenize","compile","select","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","contains","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","a","b","pop","pushNative","list","booleans","whitespace","identifier","attributes","pseudos","rwhitespace","RegExp","rtrim","rcomma","rcombinators","rdescend","rpseudo","ridentifier","matchExpr","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escape","nonHex","high","String","fromCharCode","rcssescape","fcssescape","ch","asCodePoint","charCodeAt","unloadHandler","inDisabledFieldset","addCombinator","disabled","nodeName","dir","next","childNodes","e","els","seed","m","nid","match","groups","newSelector","newContext","ownerDocument","exec","getElementById","id","getElementsByTagName","getElementsByClassName","qsa","test","testContext","scope","toSelector","join","querySelectorAll","qsaError","removeAttribute","keys","cache","key","cacheLength","shift","markFunction","assert","el","addHandle","attrs","handler","attrHandle","siblingCheck","cur","diff","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","namespace","namespaceURI","documentElement","hasCompare","subWindow","defaultView","top","addEventListener","attachEvent","className","createComment","getById","getElementsByName","filter","attrId","find","getAttributeNode","tag","tmp","input","innerHTML","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","unshift","expr","elements","attr","specified","sel","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","firstChild","nodeValue","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","check","result","what","_argument","simple","forward","ofType","_context","xml","uniqueCache","outerCache","nodeIndex","start","parent","useCache","lastChild","uniqueID","pseudo","args","setFilters","idx","matched","matcher","unmatched","lang","elemLang","hash","location","activeElement","hasFocus","href","tabIndex","checked","selected","selectedIndex","_matchIndexes","radio","checkbox","file","password","image","submit","reset","tokens","combinator","base","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","contexts","multipleContexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","filters","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","token","compiled","_name","defaultValue","unique","isXMLDoc","escapeSelector","until","truncate","is","siblings","n","rneedsContext","needsContext","rsingleTag","winnow","qualifier","not","self","rootjQuery","root","parseHTML","ready","rparentsprev","guaranteedUnique","children","contents","prev","sibling","has","targets","l","closest","index","prevAll","add","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","content","reverse","rnothtmlwhite","Identity","v","Thrower","ex","adoptValue","resolve","reject","noValue","method","promise","fail","Callbacks","object","_","flag","createOptions","firing","memory","fired","locked","queue","firingIndex","fire","once","stopOnFalse","remove","empty","disable","lock","fireWith","Deferred","func","tuples","state","always","deferred","pipe","fns","newDefer","tuple","returned","progress","notify","onFulfilled","onRejected","onProgress","maxDepth","depth","special","that","mightThrow","TypeError","notifyWith","resolveWith","process","exceptionHook","stackTrace","rejectWith","getStackHook","stateString","when","singleValue","remaining","resolveContexts","resolveValues","primary","updateFunc","rerrorNames","stack","warn","message","readyException","readyList","completed","removeEventListener","catch","readyWait","wait","readyState","doScroll","access","chainable","emptyGet","raw","bulk","_key","rmsPrefix","rdashAlpha","fcamelCase","_all","letter","toUpperCase","camelCase","string","acceptData","owner","Data","uid","defineProperty","configurable","set","prop","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","JSON","parse","getData","removeData","_data","_removeData","dequeue","startLength","hooks","_queueHooks","stop","setter","clearQueue","count","defer","pnum","source","rcssNum","cssExpand","isAttached","composed","getRootNode","isHiddenWithinTree","style","display","css","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","initial","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","body","showHide","show","values","hide","toggle","div","rcheckableType","rtagName","rscriptType","createDocumentFragment","checkClone","cloneNode","noCloneChecked","option","wrapMap","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","tbody","tfoot","colgroup","caption","th","optgroup","buildFragment","scripts","selection","ignored","wrap","attached","fragment","nodes","htmlPrefilter","createTextNode","rtypenamespace","returnTrue","returnFalse","expectSync","err","safeActiveElement","types","one","origFn","event","off","leverageNative","notAsync","saved","isTrigger","delegateType","stopPropagation","stopImmediatePropagation","preventDefault","trigger","Event","handleObjIn","eventHandle","events","t","handleObj","handlers","namespaces","origType","elemData","create","handle","triggered","dispatch","bindType","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","postDispatch","matchedHandlers","matchedSelectors","button","addProp","hook","enumerable","originalEvent","writable","load","noBubble","click","beforeunload","returnValue","props","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","now","isSimulated","altKey","bubbles","cancelable","changedTouches","ctrlKey","detail","eventPhase","metaKey","pageX","pageY","shiftKey","view","charCode","keyCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","which","focus","blur","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","valueIsFunction","html","_evalUrl","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","append","prepend","insertBefore","before","after","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","original","insert","rnumnonpx","getStyles","opener","getComputedStyle","swap","old","rboxStyle","curCSS","computed","width","minWidth","maxWidth","getPropertyValue","pixelBoxStyles","addGetHookIf","conditionFn","hookFn","computeStyleTests","container","cssText","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","marginLeft","right","pixelBoxStylesVal","boxSizingReliableVal","position","scrollboxSizeVal","offsetWidth","measure","round","parseFloat","reliableTrDimensionsVal","backgroundClip","clearCloneStyle","boxSizingReliable","pixelPosition","reliableMarginLeft","scrollboxSize","reliableTrDimensions","table","trChild","trStyle","height","parseInt","borderTopWidth","borderBottomWidth","offsetHeight","cssPrefixes","emptyStyle","vendorProps","finalPropName","cssProps","capName","vendorPropName","rdisplayswap","rcustomProp","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","max","boxModelAdjustment","dimension","box","isBorderBox","styles","computedVal","extra","delta","ceil","getWidthOrHeight","valueIsBorderBox","offsetProp","getClientRects","Tween","easing","cssHooks","opacity","origName","isCustomProp","setProperty","isFinite","getBoundingClientRect","scrollboxSizeBuggy","left","margin","padding","border","prefix","suffix","expand","expanded","parts","propHooks","run","percent","eased","duration","pos","step","fx","scrollTop","scrollLeft","linear","p","swing","cos","PI","fxNow","inProgress","rfxtypes","rrun","schedule","hidden","requestAnimationFrame","interval","tick","createFxNow","genFx","includeWidth","createTween","animation","Animation","tweeners","properties","stopped","prefilters","currentTime","startTime","tweens","opts","specialEasing","originalProperties","originalOptions","gotoEnd","propFilter","bind","complete","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","speed","opt","speeds","fadeTo","to","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","delay","time","timeout","clearTimeout","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","bool","attrNames","getter","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","classesToArray","removeProp","propFix","tabindex","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","isValidValue","classNames","hasClass","rreturn","valHooks","optionSet","focusin","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","simulate","triggerHandler","attaches","rquery","parseXML","parserErrorElem","DOMParser","parseFromString","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","param","s","valueOrFunction","encodeURIComponent","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","transports","allTypes","originAnchor","addToPrefiltersOrTransports","structure","dataTypeExpression","dataType","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","active","lastModified","etag","url","isLocal","protocol","processData","async","contentType","accepts","json","responseFields","converters","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","urlAnchor","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeaders","requestHeadersNames","strAbort","getResponseHeader","getAllResponseHeaders","setRequestHeader","overrideMimeType","mimeType","status","abort","statusText","finalText","crossDomain","host","hasContent","ifModified","headers","beforeSend","success","send","nativeStatusText","responses","isSuccess","response","modified","ct","finalDataType","firstDataType","ajaxHandleResponses","conv2","current","conv","dataFilter","throws","ajaxConvert","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","xhr","XMLHttpRequest","xhrSuccessStatus","xhrSupported","cors","errorCallback","open","username","xhrFields","onload","onerror","onabort","ontimeout","onreadystatechange","responseType","responseText","binary","scriptAttrs","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","parsed","params","animated","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","unbind","delegate","undelegate","hover","fnOver","fnOut","proxy","holdReady","hold","parseJSON","isNumeric","isNaN","trim","_jQuery","_$","noConflict","require","Promise","fetch","createIdentityEvent","pageUrl","email","firstname","lastname","createAddCartEvent","referenceId","productId","item_id","deleteGuest","guestRef","retrieveGuest","updateGuest","city","country","gender","saveGuestData","language","planName","county","lastStep","eventName","pathname","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","d","definition","o"],"sourceRoot":""}