SHARE
TWEET

forms.2

bulfaitelo Oct 10th, 2019 270 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /******/ (function(modules) { // webpackBootstrap
  2. /******/    // The module cache
  3. /******/    var installedModules = {};
  4. /******/
  5. /******/    // The require function
  6. /******/    function __webpack_require__(moduleId) {
  7. /******/
  8. /******/        // Check if module is in cache
  9. /******/        if(installedModules[moduleId]) {
  10. /******/            return installedModules[moduleId].exports;
  11. /******/        }
  12. /******/        // Create a new module (and put it into the cache)
  13. /******/        var module = installedModules[moduleId] = {
  14. /******/            i: moduleId,
  15. /******/            l: false,
  16. /******/            exports: {}
  17. /******/        };
  18. /******/
  19. /******/        // Execute the module function
  20. /******/        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  21. /******/
  22. /******/        // Flag the module as loaded
  23. /******/        module.l = true;
  24. /******/
  25. /******/        // Return the exports of the module
  26. /******/        return module.exports;
  27. /******/    }
  28. /******/
  29. /******/
  30. /******/    // expose the modules object (__webpack_modules__)
  31. /******/    __webpack_require__.m = modules;
  32. /******/
  33. /******/    // expose the module cache
  34. /******/    __webpack_require__.c = installedModules;
  35. /******/
  36. /******/    // define getter function for harmony exports
  37. /******/    __webpack_require__.d = function(exports, name, getter) {
  38. /******/        if(!__webpack_require__.o(exports, name)) {
  39. /******/            Object.defineProperty(exports, name, { enumerable: true, get: getter });
  40. /******/        }
  41. /******/    };
  42. /******/
  43. /******/    // define __esModule on exports
  44. /******/    __webpack_require__.r = function(exports) {
  45. /******/        if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  46. /******/            Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  47. /******/        }
  48. /******/        Object.defineProperty(exports, '__esModule', { value: true });
  49. /******/    };
  50. /******/
  51. /******/    // create a fake namespace object
  52. /******/    // mode & 1: value is a module id, require it
  53. /******/    // mode & 2: merge all properties of value into the ns
  54. /******/    // mode & 4: return value when already ns object
  55. /******/    // mode & 8|1: behave like require
  56. /******/    __webpack_require__.t = function(value, mode) {
  57. /******/        if(mode & 1) value = __webpack_require__(value);
  58. /******/        if(mode & 8) return value;
  59. /******/        if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  60. /******/        var ns = Object.create(null);
  61. /******/        __webpack_require__.r(ns);
  62. /******/        Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  63. /******/        if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  64. /******/        return ns;
  65. /******/    };
  66. /******/
  67. /******/    // getDefaultExport function for compatibility with non-harmony modules
  68. /******/    __webpack_require__.n = function(module) {
  69. /******/        var getter = module && module.__esModule ?
  70. /******/            function getDefault() { return module['default']; } :
  71. /******/            function getModuleExports() { return module; };
  72. /******/        __webpack_require__.d(getter, 'a', getter);
  73. /******/        return getter;
  74. /******/    };
  75. /******/
  76. /******/    // Object.prototype.hasOwnProperty.call
  77. /******/    __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  78. /******/
  79. /******/    // __webpack_public_path__
  80. /******/    __webpack_require__.p = "/";
  81. /******/
  82. /******/
  83. /******/    // Load entry module and return exports
  84. /******/    return __webpack_require__(__webpack_require__.s = 1);
  85. /******/ })
  86. /************************************************************************/
  87. /******/ ({
  88.  
  89. /***/ "./node_modules/jquery/dist/jquery.js":
  90. /*!********************************************!*\
  91.   !*** ./node_modules/jquery/dist/jquery.js ***!
  92.   \********************************************/
  93. /*! no static exports found */
  94. /***/ (function(module, exports, __webpack_require__) {
  95.  
  96. var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
  97.  * jQuery JavaScript Library v3.4.1
  98.  * https://jquery.com/
  99.  *
  100.  * Includes Sizzle.js
  101.  * https://sizzlejs.com/
  102.  *
  103.  * Copyright JS Foundation and other contributors
  104.  * Released under the MIT license
  105.  * https://jquery.org/license
  106.  *
  107.  * Date: 2019-05-01T21:04Z
  108.  */
  109. ( function( global, factory ) {
  110.  
  111.     "use strict";
  112.  
  113.     if (  true && typeof module.exports === "object" ) {
  114.  
  115.         // For CommonJS and CommonJS-like environments where a proper `window`
  116.         // is present, execute the factory and get jQuery.
  117.         // For environments that do not have a `window` with a `document`
  118.         // (such as Node.js), expose a factory as module.exports.
  119.         // This accentuates the need for the creation of a real `window`.
  120.         // e.g. var jQuery = require("jquery")(window);
  121.         // See ticket #14549 for more info.
  122.         module.exports = global.document ?
  123.             factory( global, true ) :
  124.             function( w ) {
  125.                 if ( !w.document ) {
  126.                     throw new Error( "jQuery requires a window with a document" );
  127.                 }
  128.                 return factory( w );
  129.             };
  130.     } else {
  131.         factory( global );
  132.     }
  133.  
  134. // Pass this if window is not defined yet
  135. } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
  136.  
  137. // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
  138. // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
  139. // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
  140. // enough that all such attempts are guarded in a try block.
  141. "use strict";
  142.  
  143. var arr = [];
  144.  
  145. var document = window.document;
  146.  
  147. var getProto = Object.getPrototypeOf;
  148.  
  149. var slice = arr.slice;
  150.  
  151. var concat = arr.concat;
  152.  
  153. var push = arr.push;
  154.  
  155. var indexOf = arr.indexOf;
  156.  
  157. var class2type = {};
  158.  
  159. var toString = class2type.toString;
  160.  
  161. var hasOwn = class2type.hasOwnProperty;
  162.  
  163. var fnToString = hasOwn.toString;
  164.  
  165. var ObjectFunctionString = fnToString.call( Object );
  166.  
  167. var support = {};
  168.  
  169. var isFunction = function isFunction( obj ) {
  170.  
  171.       // Support: Chrome <=57, Firefox <=52
  172.       // In some browsers, typeof returns "function" for HTML <object> elements
  173.       // (i.e., `typeof document.createElement( "object" ) === "function"`).
  174.       // We don't want to classify *any* DOM node as a function.
  175.       return typeof obj === "function" && typeof obj.nodeType !== "number";
  176.   };
  177.  
  178.  
  179. var isWindow = function isWindow( obj ) {
  180.         return obj != null && obj === obj.window;
  181.     };
  182.  
  183.  
  184.  
  185.  
  186.     var preservedScriptAttributes = {
  187.         type: true,
  188.         src: true,
  189.         nonce: true,
  190.         noModule: true
  191.     };
  192.  
  193.     function DOMEval( code, node, doc ) {
  194.         doc = doc || document;
  195.  
  196.         var i, val,
  197.             script = doc.createElement( "script" );
  198.  
  199.         script.text = code;
  200.         if ( node ) {
  201.             for ( i in preservedScriptAttributes ) {
  202.  
  203.                 // Support: Firefox 64+, Edge 18+
  204.                 // Some browsers don't support the "nonce" property on scripts.
  205.                 // On the other hand, just using `getAttribute` is not enough as
  206.                 // the `nonce` attribute is reset to an empty string whenever it
  207.                 // becomes browsing-context connected.
  208.                 // See https://github.com/whatwg/html/issues/2369
  209.                 // See https://html.spec.whatwg.org/#nonce-attributes
  210.                 // The `node.getAttribute` check was added for the sake of
  211.                 // `jQuery.globalEval` so that it can fake a nonce-containing node
  212.                 // via an object.
  213.                 val = node[ i ] || node.getAttribute && node.getAttribute( i );
  214.                 if ( val ) {
  215.                     script.setAttribute( i, val );
  216.                 }
  217.             }
  218.         }
  219.         doc.head.appendChild( script ).parentNode.removeChild( script );
  220.     }
  221.  
  222.  
  223. function toType( obj ) {
  224.     if ( obj == null ) {
  225.         return obj + "";
  226.     }
  227.  
  228.     // Support: Android <=2.3 only (functionish RegExp)
  229.     return typeof obj === "object" || typeof obj === "function" ?
  230.         class2type[ toString.call( obj ) ] || "object" :
  231.         typeof obj;
  232. }
  233. /* global Symbol */
  234. // Defining this global in .eslintrc.json would create a danger of using the global
  235. // unguarded in another place, it seems safer to define global only for this module
  236.  
  237.  
  238.  
  239. var
  240.     version = "3.4.1",
  241.  
  242.     // Define a local copy of jQuery
  243.     jQuery = function( selector, context ) {
  244.  
  245.         // The jQuery object is actually just the init constructor 'enhanced'
  246.         // Need init if jQuery is called (just allow error to be thrown if not included)
  247.         return new jQuery.fn.init( selector, context );
  248.     },
  249.  
  250.     // Support: Android <=4.0 only
  251.     // Make sure we trim BOM and NBSP
  252.     rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
  253.  
  254. jQuery.fn = jQuery.prototype = {
  255.  
  256.     // The current version of jQuery being used
  257.     jquery: version,
  258.  
  259.     constructor: jQuery,
  260.  
  261.     // The default length of a jQuery object is 0
  262.     length: 0,
  263.  
  264.     toArray: function() {
  265.         return slice.call( this );
  266.     },
  267.  
  268.     // Get the Nth element in the matched element set OR
  269.     // Get the whole matched element set as a clean array
  270.     get: function( num ) {
  271.  
  272.         // Return all the elements in a clean array
  273.         if ( num == null ) {
  274.             return slice.call( this );
  275.         }
  276.  
  277.         // Return just the one element from the set
  278.         return num < 0 ? this[ num + this.length ] : this[ num ];
  279.     },
  280.  
  281.     // Take an array of elements and push it onto the stack
  282.     // (returning the new matched element set)
  283.     pushStack: function( elems ) {
  284.  
  285.         // Build a new jQuery matched element set
  286.         var ret = jQuery.merge( this.constructor(), elems );
  287.  
  288.         // Add the old object onto the stack (as a reference)
  289.         ret.prevObject = this;
  290.  
  291.         // Return the newly-formed element set
  292.         return ret;
  293.     },
  294.  
  295.     // Execute a callback for every element in the matched set.
  296.     each: function( callback ) {
  297.         return jQuery.each( this, callback );
  298.     },
  299.  
  300.     map: function( callback ) {
  301.         return this.pushStack( jQuery.map( this, function( elem, i ) {
  302.             return callback.call( elem, i, elem );
  303.         } ) );
  304.     },
  305.  
  306.     slice: function() {
  307.         return this.pushStack( slice.apply( this, arguments ) );
  308.     },
  309.  
  310.     first: function() {
  311.         return this.eq( 0 );
  312.     },
  313.  
  314.     last: function() {
  315.         return this.eq( -1 );
  316.     },
  317.  
  318.     eq: function( i ) {
  319.         var len = this.length,
  320.             j = +i + ( i < 0 ? len : 0 );
  321.         return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
  322.     },
  323.  
  324.     end: function() {
  325.         return this.prevObject || this.constructor();
  326.     },
  327.  
  328.     // For internal use only.
  329.     // Behaves like an Array's method, not like a jQuery method.
  330.     push: push,
  331.     sort: arr.sort,
  332.     splice: arr.splice
  333. };
  334.  
  335. jQuery.extend = jQuery.fn.extend = function() {
  336.     var options, name, src, copy, copyIsArray, clone,
  337.         target = arguments[ 0 ] || {},
  338.         i = 1,
  339.         length = arguments.length,
  340.         deep = false;
  341.  
  342.     // Handle a deep copy situation
  343.     if ( typeof target === "boolean" ) {
  344.         deep = target;
  345.  
  346.         // Skip the boolean and the target
  347.         target = arguments[ i ] || {};
  348.         i++;
  349.     }
  350.  
  351.     // Handle case when target is a string or something (possible in deep copy)
  352.     if ( typeof target !== "object" && !isFunction( target ) ) {
  353.         target = {};
  354.     }
  355.  
  356.     // Extend jQuery itself if only one argument is passed
  357.     if ( i === length ) {
  358.         target = this;
  359.         i--;
  360.     }
  361.  
  362.     for ( ; i < length; i++ ) {
  363.  
  364.         // Only deal with non-null/undefined values
  365.         if ( ( options = arguments[ i ] ) != null ) {
  366.  
  367.             // Extend the base object
  368.             for ( name in options ) {
  369.                 copy = options[ name ];
  370.  
  371.                 // Prevent Object.prototype pollution
  372.                 // Prevent never-ending loop
  373.                 if ( name === "__proto__" || target === copy ) {
  374.                     continue;
  375.                 }
  376.  
  377.                 // Recurse if we're merging plain objects or arrays
  378.                 if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
  379.                     ( copyIsArray = Array.isArray( copy ) ) ) ) {
  380.                     src = target[ name ];
  381.  
  382.                     // Ensure proper type for the source value
  383.                     if ( copyIsArray && !Array.isArray( src ) ) {
  384.                         clone = [];
  385.                     } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
  386.                         clone = {};
  387.                     } else {
  388.                         clone = src;
  389.                     }
  390.                     copyIsArray = false;
  391.  
  392.                     // Never move original objects, clone them
  393.                     target[ name ] = jQuery.extend( deep, clone, copy );
  394.  
  395.                 // Don't bring in undefined values
  396.                 } else if ( copy !== undefined ) {
  397.                     target[ name ] = copy;
  398.                 }
  399.             }
  400.         }
  401.     }
  402.  
  403.     // Return the modified object
  404.     return target;
  405. };
  406.  
  407. jQuery.extend( {
  408.  
  409.     // Unique for each copy of jQuery on the page
  410.     expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
  411.  
  412.     // Assume jQuery is ready without the ready module
  413.     isReady: true,
  414.  
  415.     error: function( msg ) {
  416.         throw new Error( msg );
  417.     },
  418.  
  419.     noop: function() {},
  420.  
  421.     isPlainObject: function( obj ) {
  422.         var proto, Ctor;
  423.  
  424.         // Detect obvious negatives
  425.         // Use toString instead of jQuery.type to catch host objects
  426.         if ( !obj || toString.call( obj ) !== "[object Object]" ) {
  427.             return false;
  428.         }
  429.  
  430.         proto = getProto( obj );
  431.  
  432.         // Objects with no prototype (e.g., `Object.create( null )`) are plain
  433.         if ( !proto ) {
  434.             return true;
  435.         }
  436.  
  437.         // Objects with prototype are plain iff they were constructed by a global Object function
  438.         Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
  439.         return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
  440.     },
  441.  
  442.     isEmptyObject: function( obj ) {
  443.         var name;
  444.  
  445.         for ( name in obj ) {
  446.             return false;
  447.         }
  448.         return true;
  449.     },
  450.  
  451.     // Evaluates a script in a global context
  452.     globalEval: function( code, options ) {
  453.         DOMEval( code, { nonce: options && options.nonce } );
  454.     },
  455.  
  456.     each: function( obj, callback ) {
  457.         var length, i = 0;
  458.  
  459.         if ( isArrayLike( obj ) ) {
  460.             length = obj.length;
  461.             for ( ; i < length; i++ ) {
  462.                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
  463.                     break;
  464.                 }
  465.             }
  466.         } else {
  467.             for ( i in obj ) {
  468.                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
  469.                     break;
  470.                 }
  471.             }
  472.         }
  473.  
  474.         return obj;
  475.     },
  476.  
  477.     // Support: Android <=4.0 only
  478.     trim: function( text ) {
  479.         return text == null ?
  480.             "" :
  481.             ( text + "" ).replace( rtrim, "" );
  482.     },
  483.  
  484.     // results is for internal usage only
  485.     makeArray: function( arr, results ) {
  486.         var ret = results || [];
  487.  
  488.         if ( arr != null ) {
  489.             if ( isArrayLike( Object( arr ) ) ) {
  490.                 jQuery.merge( ret,
  491.                     typeof arr === "string" ?
  492.                     [ arr ] : arr
  493.                 );
  494.             } else {
  495.                 push.call( ret, arr );
  496.             }
  497.         }
  498.  
  499.         return ret;
  500.     },
  501.  
  502.     inArray: function( elem, arr, i ) {
  503.         return arr == null ? -1 : indexOf.call( arr, elem, i );
  504.     },
  505.  
  506.     // Support: Android <=4.0 only, PhantomJS 1 only
  507.     // push.apply(_, arraylike) throws on ancient WebKit
  508.     merge: function( first, second ) {
  509.         var len = +second.length,
  510.             j = 0,
  511.             i = first.length;
  512.  
  513.         for ( ; j < len; j++ ) {
  514.             first[ i++ ] = second[ j ];
  515.         }
  516.  
  517.         first.length = i;
  518.  
  519.         return first;
  520.     },
  521.  
  522.     grep: function( elems, callback, invert ) {
  523.         var callbackInverse,
  524.             matches = [],
  525.             i = 0,
  526.             length = elems.length,
  527.             callbackExpect = !invert;
  528.  
  529.         // Go through the array, only saving the items
  530.         // that pass the validator function
  531.         for ( ; i < length; i++ ) {
  532.             callbackInverse = !callback( elems[ i ], i );
  533.             if ( callbackInverse !== callbackExpect ) {
  534.                 matches.push( elems[ i ] );
  535.             }
  536.         }
  537.  
  538.         return matches;
  539.     },
  540.  
  541.     // arg is for internal usage only
  542.     map: function( elems, callback, arg ) {
  543.         var length, value,
  544.             i = 0,
  545.             ret = [];
  546.  
  547.         // Go through the array, translating each of the items to their new values
  548.         if ( isArrayLike( elems ) ) {
  549.             length = elems.length;
  550.             for ( ; i < length; i++ ) {
  551.                 value = callback( elems[ i ], i, arg );
  552.  
  553.                 if ( value != null ) {
  554.                     ret.push( value );
  555.                 }
  556.             }
  557.  
  558.         // Go through every key on the object,
  559.         } else {
  560.             for ( i in elems ) {
  561.                 value = callback( elems[ i ], i, arg );
  562.  
  563.                 if ( value != null ) {
  564.                     ret.push( value );
  565.                 }
  566.             }
  567.         }
  568.  
  569.         // Flatten any nested arrays
  570.         return concat.apply( [], ret );
  571.     },
  572.  
  573.     // A global GUID counter for objects
  574.     guid: 1,
  575.  
  576.     // jQuery.support is not used in Core but other projects attach their
  577.     // properties to it so it needs to exist.
  578.     support: support
  579. } );
  580.  
  581. if ( typeof Symbol === "function" ) {
  582.     jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
  583. }
  584.  
  585. // Populate the class2type map
  586. jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
  587. function( i, name ) {
  588.     class2type[ "[object " + name + "]" ] = name.toLowerCase();
  589. } );
  590.  
  591. function isArrayLike( obj ) {
  592.  
  593.     // Support: real iOS 8.2 only (not reproducible in simulator)
  594.     // `in` check used to prevent JIT error (gh-2145)
  595.     // hasOwn isn't used here due to false negatives
  596.     // regarding Nodelist length in IE
  597.     var length = !!obj && "length" in obj && obj.length,
  598.         type = toType( obj );
  599.  
  600.     if ( isFunction( obj ) || isWindow( obj ) ) {
  601.         return false;
  602.     }
  603.  
  604.     return type === "array" || length === 0 ||
  605.         typeof length === "number" && length > 0 && ( length - 1 ) in obj;
  606. }
  607. var Sizzle =
  608. /*!
  609.  * Sizzle CSS Selector Engine v2.3.4
  610.  * https://sizzlejs.com/
  611.  *
  612.  * Copyright JS Foundation and other contributors
  613.  * Released under the MIT license
  614.  * https://js.foundation/
  615.  *
  616.  * Date: 2019-04-08
  617.  */
  618. (function( window ) {
  619.  
  620. var i,
  621.     support,
  622.     Expr,
  623.     getText,
  624.     isXML,
  625.     tokenize,
  626.     compile,
  627.     select,
  628.     outermostContext,
  629.     sortInput,
  630.     hasDuplicate,
  631.  
  632.     // Local document vars
  633.     setDocument,
  634.     document,
  635.     docElem,
  636.     documentIsHTML,
  637.     rbuggyQSA,
  638.     rbuggyMatches,
  639.     matches,
  640.     contains,
  641.  
  642.     // Instance-specific data
  643.     expando = "sizzle" + 1 * new Date(),
  644.     preferredDoc = window.document,
  645.     dirruns = 0,
  646.     done = 0,
  647.     classCache = createCache(),
  648.     tokenCache = createCache(),
  649.     compilerCache = createCache(),
  650.     nonnativeSelectorCache = createCache(),
  651.     sortOrder = function( a, b ) {
  652.         if ( a === b ) {
  653.             hasDuplicate = true;
  654.         }
  655.         return 0;
  656.     },
  657.  
  658.     // Instance methods
  659.     hasOwn = ({}).hasOwnProperty,
  660.     arr = [],
  661.     pop = arr.pop,
  662.     push_native = arr.push,
  663.     push = arr.push,
  664.     slice = arr.slice,
  665.     // Use a stripped-down indexOf as it's faster than native
  666.     // https://jsperf.com/thor-indexof-vs-for/5
  667.     indexOf = function( list, elem ) {
  668.         var i = 0,
  669.             len = list.length;
  670.         for ( ; i < len; i++ ) {
  671.             if ( list[i] === elem ) {
  672.                 return i;
  673.             }
  674.         }
  675.         return -1;
  676.     },
  677.  
  678.     booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
  679.  
  680.     // Regular expressions
  681.  
  682.     // http://www.w3.org/TR/css3-selectors/#whitespace
  683.     whitespace = "[\\x20\\t\\r\\n\\f]",
  684.  
  685.     // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
  686.     identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
  687.  
  688.     // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
  689.     attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
  690.         // Operator (capture 2)
  691.         "*([*^$|!~]?=)" + whitespace +
  692.         // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
  693.         "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
  694.         "*\\]",
  695.  
  696.     pseudos = ":(" + identifier + ")(?:\\((" +
  697.         // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
  698.         // 1. quoted (capture 3; capture 4 or capture 5)
  699.         "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
  700.         // 2. simple (capture 6)
  701.         "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
  702.         // 3. anything else (capture 2)
  703.         ".*" +
  704.         ")\\)|)",
  705.  
  706.     // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
  707.     rwhitespace = new RegExp( whitespace + "+", "g" ),
  708.     rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
  709.  
  710.     rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
  711.     rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
  712.     rdescend = new RegExp( whitespace + "|>" ),
  713.  
  714.     rpseudo = new RegExp( pseudos ),
  715.     ridentifier = new RegExp( "^" + identifier + "$" ),
  716.  
  717.     matchExpr = {
  718.         "ID": new RegExp( "^#(" + identifier + ")" ),
  719.         "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
  720.         "TAG": new RegExp( "^(" + identifier + "|[*])" ),
  721.         "ATTR": new RegExp( "^" + attributes ),
  722.         "PSEUDO": new RegExp( "^" + pseudos ),
  723.         "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
  724.             "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
  725.             "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
  726.         "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
  727.         // For use in libraries implementing .is()
  728.         // We use this for POS matching in `select`
  729.         "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
  730.             whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
  731.     },
  732.  
  733.     rhtml = /HTML$/i,
  734.     rinputs = /^(?:input|select|textarea|button)$/i,
  735.     rheader = /^h\d$/i,
  736.  
  737.     rnative = /^[^{]+\{\s*\[native \w/,
  738.  
  739.     // Easily-parseable/retrievable ID or TAG or CLASS selectors
  740.     rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
  741.  
  742.     rsibling = /[+~]/,
  743.  
  744.     // CSS escapes
  745.     // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
  746.     runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
  747.     funescape = function( _, escaped, escapedWhitespace ) {
  748.         var high = "0x" + escaped - 0x10000;
  749.         // NaN means non-codepoint
  750.         // Support: Firefox<24
  751.         // Workaround erroneous numeric interpretation of +"0x"
  752.         return high !== high || escapedWhitespace ?
  753.             escaped :
  754.             high < 0 ?
  755.                 // BMP codepoint
  756.                 String.fromCharCode( high + 0x10000 ) :
  757.                 // Supplemental Plane codepoint (surrogate pair)
  758.                 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
  759.     },
  760.  
  761.     // CSS string/identifier serialization
  762.     // https://drafts.csswg.org/cssom/#common-serializing-idioms
  763.     rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
  764.     fcssescape = function( ch, asCodePoint ) {
  765.         if ( asCodePoint ) {
  766.  
  767.             // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
  768.             if ( ch === "\0" ) {
  769.                 return "\uFFFD";
  770.             }
  771.  
  772.             // Control characters and (dependent upon position) numbers get escaped as code points
  773.             return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
  774.         }
  775.  
  776.         // Other potentially-special ASCII characters get backslash-escaped
  777.         return "\\" + ch;
  778.     },
  779.  
  780.     // Used for iframes
  781.     // See setDocument()
  782.     // Removing the function wrapper causes a "Permission Denied"
  783.     // error in IE
  784.     unloadHandler = function() {
  785.         setDocument();
  786.     },
  787.  
  788.     inDisabledFieldset = addCombinator(
  789.         function( elem ) {
  790.             return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
  791.         },
  792.         { dir: "parentNode", next: "legend" }
  793.     );
  794.  
  795. // Optimize for push.apply( _, NodeList )
  796. try {
  797.     push.apply(
  798.         (arr = slice.call( preferredDoc.childNodes )),
  799.         preferredDoc.childNodes
  800.     );
  801.     // Support: Android<4.0
  802.     // Detect silently failing push.apply
  803.     arr[ preferredDoc.childNodes.length ].nodeType;
  804. } catch ( e ) {
  805.     push = { apply: arr.length ?
  806.  
  807.         // Leverage slice if possible
  808.         function( target, els ) {
  809.             push_native.apply( target, slice.call(els) );
  810.         } :
  811.  
  812.         // Support: IE<9
  813.         // Otherwise append directly
  814.         function( target, els ) {
  815.             var j = target.length,
  816.                 i = 0;
  817.             // Can't trust NodeList.length
  818.             while ( (target[j++] = els[i++]) ) {}
  819.             target.length = j - 1;
  820.         }
  821.     };
  822. }
  823.  
  824. function Sizzle( selector, context, results, seed ) {
  825.     var m, i, elem, nid, match, groups, newSelector,
  826.         newContext = context && context.ownerDocument,
  827.  
  828.         // nodeType defaults to 9, since context defaults to document
  829.         nodeType = context ? context.nodeType : 9;
  830.  
  831.     results = results || [];
  832.  
  833.     // Return early from calls with invalid selector or context
  834.     if ( typeof selector !== "string" || !selector ||
  835.         nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
  836.  
  837.         return results;
  838.     }
  839.  
  840.     // Try to shortcut find operations (as opposed to filters) in HTML documents
  841.     if ( !seed ) {
  842.  
  843.         if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
  844.             setDocument( context );
  845.         }
  846.         context = context || document;
  847.  
  848.         if ( documentIsHTML ) {
  849.  
  850.             // If the selector is sufficiently simple, try using a "get*By*" DOM method
  851.             // (excepting DocumentFragment context, where the methods don't exist)
  852.             if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
  853.  
  854.                 // ID selector
  855.                 if ( (m = match[1]) ) {
  856.  
  857.                     // Document context
  858.                     if ( nodeType === 9 ) {
  859.                         if ( (elem = context.getElementById( m )) ) {
  860.  
  861.                             // Support: IE, Opera, Webkit
  862.                             // TODO: identify versions
  863.                             // getElementById can match elements by name instead of ID
  864.                             if ( elem.id === m ) {
  865.                                 results.push( elem );
  866.                                 return results;
  867.                             }
  868.                         } else {
  869.                             return results;
  870.                         }
  871.  
  872.                     // Element context
  873.                     } else {
  874.  
  875.                         // Support: IE, Opera, Webkit
  876.                         // TODO: identify versions
  877.                         // getElementById can match elements by name instead of ID
  878.                         if ( newContext && (elem = newContext.getElementById( m )) &&
  879.                             contains( context, elem ) &&
  880.                             elem.id === m ) {
  881.  
  882.                             results.push( elem );
  883.                             return results;
  884.                         }
  885.                     }
  886.  
  887.                 // Type selector
  888.                 } else if ( match[2] ) {
  889.                     push.apply( results, context.getElementsByTagName( selector ) );
  890.                     return results;
  891.  
  892.                 // Class selector
  893.                 } else if ( (m = match[3]) && support.getElementsByClassName &&
  894.                     context.getElementsByClassName ) {
  895.  
  896.                     push.apply( results, context.getElementsByClassName( m ) );
  897.                     return results;
  898.                 }
  899.             }
  900.  
  901.             // Take advantage of querySelectorAll
  902.             if ( support.qsa &&
  903.                 !nonnativeSelectorCache[ selector + " " ] &&
  904.                 (!rbuggyQSA || !rbuggyQSA.test( selector )) &&
  905.  
  906.                 // Support: IE 8 only
  907.                 // Exclude object elements
  908.                 (nodeType !== 1 || context.nodeName.toLowerCase() !== "object") ) {
  909.  
  910.                 newSelector = selector;
  911.                 newContext = context;
  912.  
  913.                 // qSA considers elements outside a scoping root when evaluating child or
  914.                 // descendant combinators, which is not what we want.
  915.                 // In such cases, we work around the behavior by prefixing every selector in the
  916.                 // list with an ID selector referencing the scope context.
  917.                 // Thanks to Andrew Dupont for this technique.
  918.                 if ( nodeType === 1 && rdescend.test( selector ) ) {
  919.  
  920.                     // Capture the context ID, setting it first if necessary
  921.                     if ( (nid = context.getAttribute( "id" )) ) {
  922.                         nid = nid.replace( rcssescape, fcssescape );
  923.                     } else {
  924.                         context.setAttribute( "id", (nid = expando) );
  925.                     }
  926.  
  927.                     // Prefix every selector in the list
  928.                     groups = tokenize( selector );
  929.                     i = groups.length;
  930.                     while ( i-- ) {
  931.                         groups[i] = "#" + nid + " " + toSelector( groups[i] );
  932.                     }
  933.                     newSelector = groups.join( "," );
  934.  
  935.                     // Expand context for sibling selectors
  936.                     newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
  937.                         context;
  938.                 }
  939.  
  940.                 try {
  941.                     push.apply( results,
  942.                         newContext.querySelectorAll( newSelector )
  943.                     );
  944.                     return results;
  945.                 } catch ( qsaError ) {
  946.                     nonnativeSelectorCache( selector, true );
  947.                 } finally {
  948.                     if ( nid === expando ) {
  949.                         context.removeAttribute( "id" );
  950.                     }
  951.                 }
  952.             }
  953.         }
  954.     }
  955.  
  956.     // All others
  957.     return select( selector.replace( rtrim, "$1" ), context, results, seed );
  958. }
  959.  
  960. /**
  961.  * Create key-value caches of limited size
  962.  * @returns {function(string, object)} Returns the Object data after storing it on itself with
  963.  *  property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
  964.  *  deleting the oldest entry
  965.  */
  966. function createCache() {
  967.     var keys = [];
  968.  
  969.     function cache( key, value ) {
  970.         // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
  971.         if ( keys.push( key + " " ) > Expr.cacheLength ) {
  972.             // Only keep the most recent entries
  973.             delete cache[ keys.shift() ];
  974.         }
  975.         return (cache[ key + " " ] = value);
  976.     }
  977.     return cache;
  978. }
  979.  
  980. /**
  981.  * Mark a function for special use by Sizzle
  982.  * @param {Function} fn The function to mark
  983.  */
  984. function markFunction( fn ) {
  985.     fn[ expando ] = true;
  986.     return fn;
  987. }
  988.  
  989. /**
  990.  * Support testing using an element
  991.  * @param {Function} fn Passed the created element and returns a boolean result
  992.  */
  993. function assert( fn ) {
  994.     var el = document.createElement("fieldset");
  995.  
  996.     try {
  997.         return !!fn( el );
  998.     } catch (e) {
  999.         return false;
  1000.     } finally {
  1001.         // Remove from its parent by default
  1002.         if ( el.parentNode ) {
  1003.             el.parentNode.removeChild( el );
  1004.         }
  1005.         // release memory in IE
  1006.         el = null;
  1007.     }
  1008. }
  1009.  
  1010. /**
  1011.  * Adds the same handler for all of the specified attrs
  1012.  * @param {String} attrs Pipe-separated list of attributes
  1013.  * @param {Function} handler The method that will be applied
  1014.  */
  1015. function addHandle( attrs, handler ) {
  1016.     var arr = attrs.split("|"),
  1017.         i = arr.length;
  1018.  
  1019.     while ( i-- ) {
  1020.         Expr.attrHandle[ arr[i] ] = handler;
  1021.     }
  1022. }
  1023.  
  1024. /**
  1025.  * Checks document order of two siblings
  1026.  * @param {Element} a
  1027.  * @param {Element} b
  1028.  * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
  1029.  */
  1030. function siblingCheck( a, b ) {
  1031.     var cur = b && a,
  1032.         diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
  1033.             a.sourceIndex - b.sourceIndex;
  1034.  
  1035.     // Use IE sourceIndex if available on both nodes
  1036.     if ( diff ) {
  1037.         return diff;
  1038.     }
  1039.  
  1040.     // Check if b follows a
  1041.     if ( cur ) {
  1042.         while ( (cur = cur.nextSibling) ) {
  1043.             if ( cur === b ) {
  1044.                 return -1;
  1045.             }
  1046.         }
  1047.     }
  1048.  
  1049.     return a ? 1 : -1;
  1050. }
  1051.  
  1052. /**
  1053.  * Returns a function to use in pseudos for input types
  1054.  * @param {String} type
  1055.  */
  1056. function createInputPseudo( type ) {
  1057.     return function( elem ) {
  1058.         var name = elem.nodeName.toLowerCase();
  1059.         return name === "input" && elem.type === type;
  1060.     };
  1061. }
  1062.  
  1063. /**
  1064.  * Returns a function to use in pseudos for buttons
  1065.  * @param {String} type
  1066.  */
  1067. function createButtonPseudo( type ) {
  1068.     return function( elem ) {
  1069.         var name = elem.nodeName.toLowerCase();
  1070.         return (name === "input" || name === "button") && elem.type === type;
  1071.     };
  1072. }
  1073.  
  1074. /**
  1075.  * Returns a function to use in pseudos for :enabled/:disabled
  1076.  * @param {Boolean} disabled true for :disabled; false for :enabled
  1077.  */
  1078. function createDisabledPseudo( disabled ) {
  1079.  
  1080.     // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
  1081.     return function( elem ) {
  1082.  
  1083.         // Only certain elements can match :enabled or :disabled
  1084.         // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
  1085.         // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
  1086.         if ( "form" in elem ) {
  1087.  
  1088.             // Check for inherited disabledness on relevant non-disabled elements:
  1089.             // * listed form-associated elements in a disabled fieldset
  1090.             //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
  1091.             //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
  1092.             // * option elements in a disabled optgroup
  1093.             //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
  1094.             // All such elements have a "form" property.
  1095.             if ( elem.parentNode && elem.disabled === false ) {
  1096.  
  1097.                 // Option elements defer to a parent optgroup if present
  1098.                 if ( "label" in elem ) {
  1099.                     if ( "label" in elem.parentNode ) {
  1100.                         return elem.parentNode.disabled === disabled;
  1101.                     } else {
  1102.                         return elem.disabled === disabled;
  1103.                     }
  1104.                 }
  1105.  
  1106.                 // Support: IE 6 - 11
  1107.                 // Use the isDisabled shortcut property to check for disabled fieldset ancestors
  1108.                 return elem.isDisabled === disabled ||
  1109.  
  1110.                     // Where there is no isDisabled, check manually
  1111.                     /* jshint -W018 */
  1112.                     elem.isDisabled !== !disabled &&
  1113.                         inDisabledFieldset( elem ) === disabled;
  1114.             }
  1115.  
  1116.             return elem.disabled === disabled;
  1117.  
  1118.         // Try to winnow out elements that can't be disabled before trusting the disabled property.
  1119.         // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
  1120.         // even exist on them, let alone have a boolean value.
  1121.         } else if ( "label" in elem ) {
  1122.             return elem.disabled === disabled;
  1123.         }
  1124.  
  1125.         // Remaining elements are neither :enabled nor :disabled
  1126.         return false;
  1127.     };
  1128. }
  1129.  
  1130. /**
  1131.  * Returns a function to use in pseudos for positionals
  1132.  * @param {Function} fn
  1133.  */
  1134. function createPositionalPseudo( fn ) {
  1135.     return markFunction(function( argument ) {
  1136.         argument = +argument;
  1137.         return markFunction(function( seed, matches ) {
  1138.             var j,
  1139.                 matchIndexes = fn( [], seed.length, argument ),
  1140.                 i = matchIndexes.length;
  1141.  
  1142.             // Match elements found at the specified indexes
  1143.             while ( i-- ) {
  1144.                 if ( seed[ (j = matchIndexes[i]) ] ) {
  1145.                     seed[j] = !(matches[j] = seed[j]);
  1146.                 }
  1147.             }
  1148.         });
  1149.     });
  1150. }
  1151.  
  1152. /**
  1153.  * Checks a node for validity as a Sizzle context
  1154.  * @param {Element|Object=} context
  1155.  * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
  1156.  */
  1157. function testContext( context ) {
  1158.     return context && typeof context.getElementsByTagName !== "undefined" && context;
  1159. }
  1160.  
  1161. // Expose support vars for convenience
  1162. support = Sizzle.support = {};
  1163.  
  1164. /**
  1165.  * Detects XML nodes
  1166.  * @param {Element|Object} elem An element or a document
  1167.  * @returns {Boolean} True iff elem is a non-HTML XML node
  1168.  */
  1169. isXML = Sizzle.isXML = function( elem ) {
  1170.     var namespace = elem.namespaceURI,
  1171.         docElem = (elem.ownerDocument || elem).documentElement;
  1172.  
  1173.     // Support: IE <=8
  1174.     // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
  1175.     // https://bugs.jquery.com/ticket/4833
  1176.     return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
  1177. };
  1178.  
  1179. /**
  1180.  * Sets document-related variables once based on the current document
  1181.  * @param {Element|Object} [doc] An element or document object to use to set the document
  1182.  * @returns {Object} Returns the current document
  1183.  */
  1184. setDocument = Sizzle.setDocument = function( node ) {
  1185.     var hasCompare, subWindow,
  1186.         doc = node ? node.ownerDocument || node : preferredDoc;
  1187.  
  1188.     // Return early if doc is invalid or already selected
  1189.     if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
  1190.         return document;
  1191.     }
  1192.  
  1193.     // Update global variables
  1194.     document = doc;
  1195.     docElem = document.documentElement;
  1196.     documentIsHTML = !isXML( document );
  1197.  
  1198.     // Support: IE 9-11, Edge
  1199.     // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
  1200.     if ( preferredDoc !== document &&
  1201.         (subWindow = document.defaultView) && subWindow.top !== subWindow ) {
  1202.  
  1203.         // Support: IE 11, Edge
  1204.         if ( subWindow.addEventListener ) {
  1205.             subWindow.addEventListener( "unload", unloadHandler, false );
  1206.  
  1207.         // Support: IE 9 - 10 only
  1208.         } else if ( subWindow.attachEvent ) {
  1209.             subWindow.attachEvent( "onunload", unloadHandler );
  1210.         }
  1211.     }
  1212.  
  1213.     /* Attributes
  1214.     ---------------------------------------------------------------------- */
  1215.  
  1216.     // Support: IE<8
  1217.     // Verify that getAttribute really returns attributes and not properties
  1218.     // (excepting IE8 booleans)
  1219.     support.attributes = assert(function( el ) {
  1220.         el.className = "i";
  1221.         return !el.getAttribute("className");
  1222.     });
  1223.  
  1224.     /* getElement(s)By*
  1225.     ---------------------------------------------------------------------- */
  1226.  
  1227.     // Check if getElementsByTagName("*") returns only elements
  1228.     support.getElementsByTagName = assert(function( el ) {
  1229.         el.appendChild( document.createComment("") );
  1230.         return !el.getElementsByTagName("*").length;
  1231.     });
  1232.  
  1233.     // Support: IE<9
  1234.     support.getElementsByClassName = rnative.test( document.getElementsByClassName );
  1235.  
  1236.     // Support: IE<10
  1237.     // Check if getElementById returns elements by name
  1238.     // The broken getElementById methods don't pick up programmatically-set names,
  1239.     // so use a roundabout getElementsByName test
  1240.     support.getById = assert(function( el ) {
  1241.         docElem.appendChild( el ).id = expando;
  1242.         return !document.getElementsByName || !document.getElementsByName( expando ).length;
  1243.     });
  1244.  
  1245.     // ID filter and find
  1246.     if ( support.getById ) {
  1247.         Expr.filter["ID"] = function( id ) {
  1248.             var attrId = id.replace( runescape, funescape );
  1249.             return function( elem ) {
  1250.                 return elem.getAttribute("id") === attrId;
  1251.             };
  1252.         };
  1253.         Expr.find["ID"] = function( id, context ) {
  1254.             if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
  1255.                 var elem = context.getElementById( id );
  1256.                 return elem ? [ elem ] : [];
  1257.             }
  1258.         };
  1259.     } else {
  1260.         Expr.filter["ID"] =  function( id ) {
  1261.             var attrId = id.replace( runescape, funescape );
  1262.             return function( elem ) {
  1263.                 var node = typeof elem.getAttributeNode !== "undefined" &&
  1264.                     elem.getAttributeNode("id");
  1265.                 return node && node.value === attrId;
  1266.             };
  1267.         };
  1268.  
  1269.         // Support: IE 6 - 7 only
  1270.         // getElementById is not reliable as a find shortcut
  1271.         Expr.find["ID"] = function( id, context ) {
  1272.             if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
  1273.                 var node, i, elems,
  1274.                     elem = context.getElementById( id );
  1275.  
  1276.                 if ( elem ) {
  1277.  
  1278.                     // Verify the id attribute
  1279.                     node = elem.getAttributeNode("id");
  1280.                     if ( node && node.value === id ) {
  1281.                         return [ elem ];
  1282.                     }
  1283.  
  1284.                     // Fall back on getElementsByName
  1285.                     elems = context.getElementsByName( id );
  1286.                     i = 0;
  1287.                     while ( (elem = elems[i++]) ) {
  1288.                         node = elem.getAttributeNode("id");
  1289.                         if ( node && node.value === id ) {
  1290.                             return [ elem ];
  1291.                         }
  1292.                     }
  1293.                 }
  1294.  
  1295.                 return [];
  1296.             }
  1297.         };
  1298.     }
  1299.  
  1300.     // Tag
  1301.     Expr.find["TAG"] = support.getElementsByTagName ?
  1302.         function( tag, context ) {
  1303.             if ( typeof context.getElementsByTagName !== "undefined" ) {
  1304.                 return context.getElementsByTagName( tag );
  1305.  
  1306.             // DocumentFragment nodes don't have gEBTN
  1307.             } else if ( support.qsa ) {
  1308.                 return context.querySelectorAll( tag );
  1309.             }
  1310.         } :
  1311.  
  1312.         function( tag, context ) {
  1313.             var elem,
  1314.                 tmp = [],
  1315.                 i = 0,
  1316.                 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
  1317.                 results = context.getElementsByTagName( tag );
  1318.  
  1319.             // Filter out possible comments
  1320.             if ( tag === "*" ) {
  1321.                 while ( (elem = results[i++]) ) {
  1322.                     if ( elem.nodeType === 1 ) {
  1323.                         tmp.push( elem );
  1324.                     }
  1325.                 }
  1326.  
  1327.                 return tmp;
  1328.             }
  1329.             return results;
  1330.         };
  1331.  
  1332.     // Class
  1333.     Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
  1334.         if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
  1335.             return context.getElementsByClassName( className );
  1336.         }
  1337.     };
  1338.  
  1339.     /* QSA/matchesSelector
  1340.     ---------------------------------------------------------------------- */
  1341.  
  1342.     // QSA and matchesSelector support
  1343.  
  1344.     // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
  1345.     rbuggyMatches = [];
  1346.  
  1347.     // qSa(:focus) reports false when true (Chrome 21)
  1348.     // We allow this because of a bug in IE8/9 that throws an error
  1349.     // whenever `document.activeElement` is accessed on an iframe
  1350.     // So, we allow :focus to pass through QSA all the time to avoid the IE error
  1351.     // See https://bugs.jquery.com/ticket/13378
  1352.     rbuggyQSA = [];
  1353.  
  1354.     if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
  1355.         // Build QSA regex
  1356.         // Regex strategy adopted from Diego Perini
  1357.         assert(function( el ) {
  1358.             // Select is set to empty string on purpose
  1359.             // This is to test IE's treatment of not explicitly
  1360.             // setting a boolean content attribute,
  1361.             // since its presence should be enough
  1362.             // https://bugs.jquery.com/ticket/12359
  1363.             docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
  1364.                 "<select id='" + expando + "-\r\\' msallowcapture=''>" +
  1365.                 "<option selected=''></option></select>";
  1366.  
  1367.             // Support: IE8, Opera 11-12.16
  1368.             // Nothing should be selected when empty strings follow ^= or $= or *=
  1369.             // The test attribute must be unknown in Opera but "safe" for WinRT
  1370.             // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
  1371.             if ( el.querySelectorAll("[msallowcapture^='']").length ) {
  1372.                 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
  1373.             }
  1374.  
  1375.             // Support: IE8
  1376.             // Boolean attributes and "value" are not treated correctly
  1377.             if ( !el.querySelectorAll("[selected]").length ) {
  1378.                 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
  1379.             }
  1380.  
  1381.             // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
  1382.             if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
  1383.                 rbuggyQSA.push("~=");
  1384.             }
  1385.  
  1386.             // Webkit/Opera - :checked should return selected option elements
  1387.             // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  1388.             // IE8 throws error here and will not see later tests
  1389.             if ( !el.querySelectorAll(":checked").length ) {
  1390.                 rbuggyQSA.push(":checked");
  1391.             }
  1392.  
  1393.             // Support: Safari 8+, iOS 8+
  1394.             // https://bugs.webkit.org/show_bug.cgi?id=136851
  1395.             // In-page `selector#id sibling-combinator selector` fails
  1396.             if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
  1397.                 rbuggyQSA.push(".#.+[+~]");
  1398.             }
  1399.         });
  1400.  
  1401.         assert(function( el ) {
  1402.             el.innerHTML = "<a href='' disabled='disabled'></a>" +
  1403.                 "<select disabled='disabled'><option/></select>";
  1404.  
  1405.             // Support: Windows 8 Native Apps
  1406.             // The type and name attributes are restricted during .innerHTML assignment
  1407.             var input = document.createElement("input");
  1408.             input.setAttribute( "type", "hidden" );
  1409.             el.appendChild( input ).setAttribute( "name", "D" );
  1410.  
  1411.             // Support: IE8
  1412.             // Enforce case-sensitivity of name attribute
  1413.             if ( el.querySelectorAll("[name=d]").length ) {
  1414.                 rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
  1415.             }
  1416.  
  1417.             // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
  1418.             // IE8 throws error here and will not see later tests
  1419.             if ( el.querySelectorAll(":enabled").length !== 2 ) {
  1420.                 rbuggyQSA.push( ":enabled", ":disabled" );
  1421.             }
  1422.  
  1423.             // Support: IE9-11+
  1424.             // IE's :disabled selector does not pick up the children of disabled fieldsets
  1425.             docElem.appendChild( el ).disabled = true;
  1426.             if ( el.querySelectorAll(":disabled").length !== 2 ) {
  1427.                 rbuggyQSA.push( ":enabled", ":disabled" );
  1428.             }
  1429.  
  1430.             // Opera 10-11 does not throw on post-comma invalid pseudos
  1431.             el.querySelectorAll("*,:x");
  1432.             rbuggyQSA.push(",.*:");
  1433.         });
  1434.     }
  1435.  
  1436.     if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
  1437.         docElem.webkitMatchesSelector ||
  1438.         docElem.mozMatchesSelector ||
  1439.         docElem.oMatchesSelector ||
  1440.         docElem.msMatchesSelector) )) ) {
  1441.  
  1442.         assert(function( el ) {
  1443.             // Check to see if it's possible to do matchesSelector
  1444.             // on a disconnected node (IE 9)
  1445.             support.disconnectedMatch = matches.call( el, "*" );
  1446.  
  1447.             // This should fail with an exception
  1448.             // Gecko does not error, returns false instead
  1449.             matches.call( el, "[s!='']:x" );
  1450.             rbuggyMatches.push( "!=", pseudos );
  1451.         });
  1452.     }
  1453.  
  1454.     rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
  1455.     rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
  1456.  
  1457.     /* Contains
  1458.     ---------------------------------------------------------------------- */
  1459.     hasCompare = rnative.test( docElem.compareDocumentPosition );
  1460.  
  1461.     // Element contains another
  1462.     // Purposefully self-exclusive
  1463.     // As in, an element does not contain itself
  1464.     contains = hasCompare || rnative.test( docElem.contains ) ?
  1465.         function( a, b ) {
  1466.             var adown = a.nodeType === 9 ? a.documentElement : a,
  1467.                 bup = b && b.parentNode;
  1468.             return a === bup || !!( bup && bup.nodeType === 1 && (
  1469.                 adown.contains ?
  1470.                     adown.contains( bup ) :
  1471.                     a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
  1472.             ));
  1473.         } :
  1474.         function( a, b ) {
  1475.             if ( b ) {
  1476.                 while ( (b = b.parentNode) ) {
  1477.                     if ( b === a ) {
  1478.                         return true;
  1479.                     }
  1480.                 }
  1481.             }
  1482.             return false;
  1483.         };
  1484.  
  1485.     /* Sorting
  1486.     ---------------------------------------------------------------------- */
  1487.  
  1488.     // Document order sorting
  1489.     sortOrder = hasCompare ?
  1490.     function( a, b ) {
  1491.  
  1492.         // Flag for duplicate removal
  1493.         if ( a === b ) {
  1494.             hasDuplicate = true;
  1495.             return 0;
  1496.         }
  1497.  
  1498.         // Sort on method existence if only one input has compareDocumentPosition
  1499.         var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
  1500.         if ( compare ) {
  1501.             return compare;
  1502.         }
  1503.  
  1504.         // Calculate position if both inputs belong to the same document
  1505.         compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
  1506.             a.compareDocumentPosition( b ) :
  1507.  
  1508.             // Otherwise we know they are disconnected
  1509.             1;
  1510.  
  1511.         // Disconnected nodes
  1512.         if ( compare & 1 ||
  1513.             (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
  1514.  
  1515.             // Choose the first element that is related to our preferred document
  1516.             if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
  1517.                 return -1;
  1518.             }
  1519.             if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
  1520.                 return 1;
  1521.             }
  1522.  
  1523.             // Maintain original order
  1524.             return sortInput ?
  1525.                 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
  1526.                 0;
  1527.         }
  1528.  
  1529.         return compare & 4 ? -1 : 1;
  1530.     } :
  1531.     function( a, b ) {
  1532.         // Exit early if the nodes are identical
  1533.         if ( a === b ) {
  1534.             hasDuplicate = true;
  1535.             return 0;
  1536.         }
  1537.  
  1538.         var cur,
  1539.             i = 0,
  1540.             aup = a.parentNode,
  1541.             bup = b.parentNode,
  1542.             ap = [ a ],
  1543.             bp = [ b ];
  1544.  
  1545.         // Parentless nodes are either documents or disconnected
  1546.         if ( !aup || !bup ) {
  1547.             return a === document ? -1 :
  1548.                 b === document ? 1 :
  1549.                 aup ? -1 :
  1550.                 bup ? 1 :
  1551.                 sortInput ?
  1552.                 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
  1553.                 0;
  1554.  
  1555.         // If the nodes are siblings, we can do a quick check
  1556.         } else if ( aup === bup ) {
  1557.             return siblingCheck( a, b );
  1558.         }
  1559.  
  1560.         // Otherwise we need full lists of their ancestors for comparison
  1561.         cur = a;
  1562.         while ( (cur = cur.parentNode) ) {
  1563.             ap.unshift( cur );
  1564.         }
  1565.         cur = b;
  1566.         while ( (cur = cur.parentNode) ) {
  1567.             bp.unshift( cur );
  1568.         }
  1569.  
  1570.         // Walk down the tree looking for a discrepancy
  1571.         while ( ap[i] === bp[i] ) {
  1572.             i++;
  1573.         }
  1574.  
  1575.         return i ?
  1576.             // Do a sibling check if the nodes have a common ancestor
  1577.             siblingCheck( ap[i], bp[i] ) :
  1578.  
  1579.             // Otherwise nodes in our document sort first
  1580.             ap[i] === preferredDoc ? -1 :
  1581.             bp[i] === preferredDoc ? 1 :
  1582.             0;
  1583.     };
  1584.  
  1585.     return document;
  1586. };
  1587.  
  1588. Sizzle.matches = function( expr, elements ) {
  1589.     return Sizzle( expr, null, null, elements );
  1590. };
  1591.  
  1592. Sizzle.matchesSelector = function( elem, expr ) {
  1593.     // Set document vars if needed
  1594.     if ( ( elem.ownerDocument || elem ) !== document ) {
  1595.         setDocument( elem );
  1596.     }
  1597.  
  1598.     if ( support.matchesSelector && documentIsHTML &&
  1599.         !nonnativeSelectorCache[ expr + " " ] &&
  1600.         ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
  1601.         ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
  1602.  
  1603.         try {
  1604.             var ret = matches.call( elem, expr );
  1605.  
  1606.             // IE 9's matchesSelector returns false on disconnected nodes
  1607.             if ( ret || support.disconnectedMatch ||
  1608.                     // As well, disconnected nodes are said to be in a document
  1609.                     // fragment in IE 9
  1610.                     elem.document && elem.document.nodeType !== 11 ) {
  1611.                 return ret;
  1612.             }
  1613.         } catch (e) {
  1614.             nonnativeSelectorCache( expr, true );
  1615.         }
  1616.     }
  1617.  
  1618.     return Sizzle( expr, document, null, [ elem ] ).length > 0;
  1619. };
  1620.  
  1621. Sizzle.contains = function( context, elem ) {
  1622.     // Set document vars if needed
  1623.     if ( ( context.ownerDocument || context ) !== document ) {
  1624.         setDocument( context );
  1625.     }
  1626.     return contains( context, elem );
  1627. };
  1628.  
  1629. Sizzle.attr = function( elem, name ) {
  1630.     // Set document vars if needed
  1631.     if ( ( elem.ownerDocument || elem ) !== document ) {
  1632.         setDocument( elem );
  1633.     }
  1634.  
  1635.     var fn = Expr.attrHandle[ name.toLowerCase() ],
  1636.         // Don't get fooled by Object.prototype properties (jQuery #13807)
  1637.         val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
  1638.             fn( elem, name, !documentIsHTML ) :
  1639.             undefined;
  1640.  
  1641.     return val !== undefined ?
  1642.         val :
  1643.         support.attributes || !documentIsHTML ?
  1644.             elem.getAttribute( name ) :
  1645.             (val = elem.getAttributeNode(name)) && val.specified ?
  1646.                 val.value :
  1647.                 null;
  1648. };
  1649.  
  1650. Sizzle.escape = function( sel ) {
  1651.     return (sel + "").replace( rcssescape, fcssescape );
  1652. };
  1653.  
  1654. Sizzle.error = function( msg ) {
  1655.     throw new Error( "Syntax error, unrecognized expression: " + msg );
  1656. };
  1657.  
  1658. /**
  1659.  * Document sorting and removing duplicates
  1660.  * @param {ArrayLike} results
  1661.  */
  1662. Sizzle.uniqueSort = function( results ) {
  1663.     var elem,
  1664.         duplicates = [],
  1665.         j = 0,
  1666.         i = 0;
  1667.  
  1668.     // Unless we *know* we can detect duplicates, assume their presence
  1669.     hasDuplicate = !support.detectDuplicates;
  1670.     sortInput = !support.sortStable && results.slice( 0 );
  1671.     results.sort( sortOrder );
  1672.  
  1673.     if ( hasDuplicate ) {
  1674.         while ( (elem = results[i++]) ) {
  1675.             if ( elem === results[ i ] ) {
  1676.                 j = duplicates.push( i );
  1677.             }
  1678.         }
  1679.         while ( j-- ) {
  1680.             results.splice( duplicates[ j ], 1 );
  1681.         }
  1682.     }
  1683.  
  1684.     // Clear input after sorting to release objects
  1685.     // See https://github.com/jquery/sizzle/pull/225
  1686.     sortInput = null;
  1687.  
  1688.     return results;
  1689. };
  1690.  
  1691. /**
  1692.  * Utility function for retrieving the text value of an array of DOM nodes
  1693.  * @param {Array|Element} elem
  1694.  */
  1695. getText = Sizzle.getText = function( elem ) {
  1696.     var node,
  1697.         ret = "",
  1698.         i = 0,
  1699.         nodeType = elem.nodeType;
  1700.  
  1701.     if ( !nodeType ) {
  1702.         // If no nodeType, this is expected to be an array
  1703.         while ( (node = elem[i++]) ) {
  1704.             // Do not traverse comment nodes
  1705.             ret += getText( node );
  1706.         }
  1707.     } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
  1708.         // Use textContent for elements
  1709.         // innerText usage removed for consistency of new lines (jQuery #11153)
  1710.         if ( typeof elem.textContent === "string" ) {
  1711.             return elem.textContent;
  1712.         } else {
  1713.             // Traverse its children
  1714.             for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
  1715.                 ret += getText( elem );
  1716.             }
  1717.         }
  1718.     } else if ( nodeType === 3 || nodeType === 4 ) {
  1719.         return elem.nodeValue;
  1720.     }
  1721.     // Do not include comment or processing instruction nodes
  1722.  
  1723.     return ret;
  1724. };
  1725.  
  1726. Expr = Sizzle.selectors = {
  1727.  
  1728.     // Can be adjusted by the user
  1729.     cacheLength: 50,
  1730.  
  1731.     createPseudo: markFunction,
  1732.  
  1733.     match: matchExpr,
  1734.  
  1735.     attrHandle: {},
  1736.  
  1737.     find: {},
  1738.  
  1739.     relative: {
  1740.         ">": { dir: "parentNode", first: true },
  1741.         " ": { dir: "parentNode" },
  1742.         "+": { dir: "previousSibling", first: true },
  1743.         "~": { dir: "previousSibling" }
  1744.     },
  1745.  
  1746.     preFilter: {
  1747.         "ATTR": function( match ) {
  1748.             match[1] = match[1].replace( runescape, funescape );
  1749.  
  1750.             // Move the given value to match[3] whether quoted or unquoted
  1751.             match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
  1752.  
  1753.             if ( match[2] === "~=" ) {
  1754.                 match[3] = " " + match[3] + " ";
  1755.             }
  1756.  
  1757.             return match.slice( 0, 4 );
  1758.         },
  1759.  
  1760.         "CHILD": function( match ) {
  1761.             /* matches from matchExpr["CHILD"]
  1762.                 1 type (only|nth|...)
  1763.                 2 what (child|of-type)
  1764.                 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
  1765.                 4 xn-component of xn+y argument ([+-]?\d*n|)
  1766.                 5 sign of xn-component
  1767.                 6 x of xn-component
  1768.                 7 sign of y-component
  1769.                 8 y of y-component
  1770.             */
  1771.             match[1] = match[1].toLowerCase();
  1772.  
  1773.             if ( match[1].slice( 0, 3 ) === "nth" ) {
  1774.                 // nth-* requires argument
  1775.                 if ( !match[3] ) {
  1776.                     Sizzle.error( match[0] );
  1777.                 }
  1778.  
  1779.                 // numeric x and y parameters for Expr.filter.CHILD
  1780.                 // remember that false/true cast respectively to 0/1
  1781.                 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
  1782.                 match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
  1783.  
  1784.             // other types prohibit arguments
  1785.             } else if ( match[3] ) {
  1786.                 Sizzle.error( match[0] );
  1787.             }
  1788.  
  1789.             return match;
  1790.         },
  1791.  
  1792.         "PSEUDO": function( match ) {
  1793.             var excess,
  1794.                 unquoted = !match[6] && match[2];
  1795.  
  1796.             if ( matchExpr["CHILD"].test( match[0] ) ) {
  1797.                 return null;
  1798.             }
  1799.  
  1800.             // Accept quoted arguments as-is
  1801.             if ( match[3] ) {
  1802.                 match[2] = match[4] || match[5] || "";
  1803.  
  1804.             // Strip excess characters from unquoted arguments
  1805.             } else if ( unquoted && rpseudo.test( unquoted ) &&
  1806.                 // Get excess from tokenize (recursively)
  1807.                 (excess = tokenize( unquoted, true )) &&
  1808.                 // advance to the next closing parenthesis
  1809.                 (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
  1810.  
  1811.                 // excess is a negative index
  1812.                 match[0] = match[0].slice( 0, excess );
  1813.                 match[2] = unquoted.slice( 0, excess );
  1814.             }
  1815.  
  1816.             // Return only captures needed by the pseudo filter method (type and argument)
  1817.             return match.slice( 0, 3 );
  1818.         }
  1819.     },
  1820.  
  1821.     filter: {
  1822.  
  1823.         "TAG": function( nodeNameSelector ) {
  1824.             var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
  1825.             return nodeNameSelector === "*" ?
  1826.                 function() { return true; } :
  1827.                 function( elem ) {
  1828.                     return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  1829.                 };
  1830.         },
  1831.  
  1832.         "CLASS": function( className ) {
  1833.             var pattern = classCache[ className + " " ];
  1834.  
  1835.             return pattern ||
  1836.                 (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
  1837.                 classCache( className, function( elem ) {
  1838.                     return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
  1839.                 });
  1840.         },
  1841.  
  1842.         "ATTR": function( name, operator, check ) {
  1843.             return function( elem ) {
  1844.                 var result = Sizzle.attr( elem, name );
  1845.  
  1846.                 if ( result == null ) {
  1847.                     return operator === "!=";
  1848.                 }
  1849.                 if ( !operator ) {
  1850.                     return true;
  1851.                 }
  1852.  
  1853.                 result += "";
  1854.  
  1855.                 return operator === "=" ? result === check :
  1856.                     operator === "!=" ? result !== check :
  1857.                     operator === "^=" ? check && result.indexOf( check ) === 0 :
  1858.                     operator === "*=" ? check && result.indexOf( check ) > -1 :
  1859.                     operator === "$=" ? check && result.slice( -check.length ) === check :
  1860.                     operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
  1861.                     operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
  1862.                     false;
  1863.             };
  1864.         },
  1865.  
  1866.         "CHILD": function( type, what, argument, first, last ) {
  1867.             var simple = type.slice( 0, 3 ) !== "nth",
  1868.                 forward = type.slice( -4 ) !== "last",
  1869.                 ofType = what === "of-type";
  1870.  
  1871.             return first === 1 && last === 0 ?
  1872.  
  1873.                 // Shortcut for :nth-*(n)
  1874.                 function( elem ) {
  1875.                     return !!elem.parentNode;
  1876.                 } :
  1877.  
  1878.                 function( elem, context, xml ) {
  1879.                     var cache, uniqueCache, outerCache, node, nodeIndex, start,
  1880.                         dir = simple !== forward ? "nextSibling" : "previousSibling",
  1881.                         parent = elem.parentNode,
  1882.                         name = ofType && elem.nodeName.toLowerCase(),
  1883.                         useCache = !xml && !ofType,
  1884.                         diff = false;
  1885.  
  1886.                     if ( parent ) {
  1887.  
  1888.                         // :(first|last|only)-(child|of-type)
  1889.                         if ( simple ) {
  1890.                             while ( dir ) {
  1891.                                 node = elem;
  1892.                                 while ( (node = node[ dir ]) ) {
  1893.                                     if ( ofType ?
  1894.                                         node.nodeName.toLowerCase() === name :
  1895.                                         node.nodeType === 1 ) {
  1896.  
  1897.                                         return false;
  1898.                                     }
  1899.                                 }
  1900.                                 // Reverse direction for :only-* (if we haven't yet done so)
  1901.                                 start = dir = type === "only" && !start && "nextSibling";
  1902.                             }
  1903.                             return true;
  1904.                         }
  1905.  
  1906.                         start = [ forward ? parent.firstChild : parent.lastChild ];
  1907.  
  1908.                         // non-xml :nth-child(...) stores cache data on `parent`
  1909.                         if ( forward && useCache ) {
  1910.  
  1911.                             // Seek `elem` from a previously-cached index
  1912.  
  1913.                             // ...in a gzip-friendly way
  1914.                             node = parent;
  1915.                             outerCache = node[ expando ] || (node[ expando ] = {});
  1916.  
  1917.                             // Support: IE <9 only
  1918.                             // Defend against cloned attroperties (jQuery gh-1709)
  1919.                             uniqueCache = outerCache[ node.uniqueID ] ||
  1920.                                 (outerCache[ node.uniqueID ] = {});
  1921.  
  1922.                             cache = uniqueCache[ type ] || [];
  1923.                             nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
  1924.                             diff = nodeIndex && cache[ 2 ];
  1925.                             node = nodeIndex && parent.childNodes[ nodeIndex ];
  1926.  
  1927.                             while ( (node = ++nodeIndex && node && node[ dir ] ||
  1928.  
  1929.                                 // Fallback to seeking `elem` from the start
  1930.                                 (diff = nodeIndex = 0) || start.pop()) ) {
  1931.  
  1932.                                 // When found, cache indexes on `parent` and break
  1933.                                 if ( node.nodeType === 1 && ++diff && node === elem ) {
  1934.                                     uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
  1935.                                     break;
  1936.                                 }
  1937.                             }
  1938.  
  1939.                         } else {
  1940.                             // Use previously-cached element index if available
  1941.                             if ( useCache ) {
  1942.                                 // ...in a gzip-friendly way
  1943.                                 node = elem;
  1944.                                 outerCache = node[ expando ] || (node[ expando ] = {});
  1945.  
  1946.                                 // Support: IE <9 only
  1947.                                 // Defend against cloned attroperties (jQuery gh-1709)
  1948.                                 uniqueCache = outerCache[ node.uniqueID ] ||
  1949.                                     (outerCache[ node.uniqueID ] = {});
  1950.  
  1951.                                 cache = uniqueCache[ type ] || [];
  1952.                                 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
  1953.                                 diff = nodeIndex;
  1954.                             }
  1955.  
  1956.                             // xml :nth-child(...)
  1957.                             // or :nth-last-child(...) or :nth(-last)?-of-type(...)
  1958.                             if ( diff === false ) {
  1959.                                 // Use the same loop as above to seek `elem` from the start
  1960.                                 while ( (node = ++nodeIndex && node && node[ dir ] ||
  1961.                                     (diff = nodeIndex = 0) || start.pop()) ) {
  1962.  
  1963.                                     if ( ( ofType ?
  1964.                                         node.nodeName.toLowerCase() === name :
  1965.                                         node.nodeType === 1 ) &&
  1966.                                         ++diff ) {
  1967.  
  1968.                                         // Cache the index of each encountered element
  1969.                                         if ( useCache ) {
  1970.                                             outerCache = node[ expando ] || (node[ expando ] = {});
  1971.  
  1972.                                             // Support: IE <9 only
  1973.                                             // Defend against cloned attroperties (jQuery gh-1709)
  1974.                                             uniqueCache = outerCache[ node.uniqueID ] ||
  1975.                                                 (outerCache[ node.uniqueID ] = {});
  1976.  
  1977.                                             uniqueCache[ type ] = [ dirruns, diff ];
  1978.                                         }
  1979.  
  1980.                                         if ( node === elem ) {
  1981.                                             break;
  1982.                                         }
  1983.                                     }
  1984.                                 }
  1985.                             }
  1986.                         }
  1987.  
  1988.                         // Incorporate the offset, then check against cycle size
  1989.                         diff -= last;
  1990.                         return diff === first || ( diff % first === 0 && diff / first >= 0 );
  1991.                     }
  1992.                 };
  1993.         },
  1994.  
  1995.         "PSEUDO": function( pseudo, argument ) {
  1996.             // pseudo-class names are case-insensitive
  1997.             // http://www.w3.org/TR/selectors/#pseudo-classes
  1998.             // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
  1999.             // Remember that setFilters inherits from pseudos
  2000.             var args,
  2001.                 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
  2002.                     Sizzle.error( "unsupported pseudo: " + pseudo );
  2003.  
  2004.             // The user may use createPseudo to indicate that
  2005.             // arguments are needed to create the filter function
  2006.             // just as Sizzle does
  2007.             if ( fn[ expando ] ) {
  2008.                 return fn( argument );
  2009.             }
  2010.  
  2011.             // But maintain support for old signatures
  2012.             if ( fn.length > 1 ) {
  2013.                 args = [ pseudo, pseudo, "", argument ];
  2014.                 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
  2015.                     markFunction(function( seed, matches ) {
  2016.                         var idx,
  2017.                             matched = fn( seed, argument ),
  2018.                             i = matched.length;
  2019.                         while ( i-- ) {
  2020.                             idx = indexOf( seed, matched[i] );
  2021.                             seed[ idx ] = !( matches[ idx ] = matched[i] );
  2022.                         }
  2023.                     }) :
  2024.                     function( elem ) {
  2025.                         return fn( elem, 0, args );
  2026.                     };
  2027.             }
  2028.  
  2029.             return fn;
  2030.         }
  2031.     },
  2032.  
  2033.     pseudos: {
  2034.         // Potentially complex pseudos
  2035.         "not": markFunction(function( selector ) {
  2036.             // Trim the selector passed to compile
  2037.             // to avoid treating leading and trailing
  2038.             // spaces as combinators
  2039.             var input = [],
  2040.                 results = [],
  2041.                 matcher = compile( selector.replace( rtrim, "$1" ) );
  2042.  
  2043.             return matcher[ expando ] ?
  2044.                 markFunction(function( seed, matches, context, xml ) {
  2045.                     var elem,
  2046.                         unmatched = matcher( seed, null, xml, [] ),
  2047.                         i = seed.length;
  2048.  
  2049.                     // Match elements unmatched by `matcher`
  2050.                     while ( i-- ) {
  2051.                         if ( (elem = unmatched[i]) ) {
  2052.                             seed[i] = !(matches[i] = elem);
  2053.                         }
  2054.                     }
  2055.                 }) :
  2056.                 function( elem, context, xml ) {
  2057.                     input[0] = elem;
  2058.                     matcher( input, null, xml, results );
  2059.                     // Don't keep the element (issue #299)
  2060.                     input[0] = null;
  2061.                     return !results.pop();
  2062.                 };
  2063.         }),
  2064.  
  2065.         "has": markFunction(function( selector ) {
  2066.             return function( elem ) {
  2067.                 return Sizzle( selector, elem ).length > 0;
  2068.             };
  2069.         }),
  2070.  
  2071.         "contains": markFunction(function( text ) {
  2072.             text = text.replace( runescape, funescape );
  2073.             return function( elem ) {
  2074.                 return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
  2075.             };
  2076.         }),
  2077.  
  2078.         // "Whether an element is represented by a :lang() selector
  2079.         // is based solely on the element's language value
  2080.         // being equal to the identifier C,
  2081.         // or beginning with the identifier C immediately followed by "-".
  2082.         // The matching of C against the element's language value is performed case-insensitively.
  2083.         // The identifier C does not have to be a valid language name."
  2084.         // http://www.w3.org/TR/selectors/#lang-pseudo
  2085.         "lang": markFunction( function( lang ) {
  2086.             // lang value must be a valid identifier
  2087.             if ( !ridentifier.test(lang || "") ) {
  2088.                 Sizzle.error( "unsupported lang: " + lang );
  2089.             }
  2090.             lang = lang.replace( runescape, funescape ).toLowerCase();
  2091.             return function( elem ) {
  2092.                 var elemLang;
  2093.                 do {
  2094.                     if ( (elemLang = documentIsHTML ?
  2095.                         elem.lang :
  2096.                         elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
  2097.  
  2098.                         elemLang = elemLang.toLowerCase();
  2099.                         return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
  2100.                     }
  2101.                 } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
  2102.                 return false;
  2103.             };
  2104.         }),
  2105.  
  2106.         // Miscellaneous
  2107.         "target": function( elem ) {
  2108.             var hash = window.location && window.location.hash;
  2109.             return hash && hash.slice( 1 ) === elem.id;
  2110.         },
  2111.  
  2112.         "root": function( elem ) {
  2113.             return elem === docElem;
  2114.         },
  2115.  
  2116.         "focus": function( elem ) {
  2117.             return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
  2118.         },
  2119.  
  2120.         // Boolean properties
  2121.         "enabled": createDisabledPseudo( false ),
  2122.         "disabled": createDisabledPseudo( true ),
  2123.  
  2124.         "checked": function( elem ) {
  2125.             // In CSS3, :checked should return both checked and selected elements
  2126.             // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  2127.             var nodeName = elem.nodeName.toLowerCase();
  2128.             return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
  2129.         },
  2130.  
  2131.         "selected": function( elem ) {
  2132.             // Accessing this property makes selected-by-default
  2133.             // options in Safari work properly
  2134.             if ( elem.parentNode ) {
  2135.                 elem.parentNode.selectedIndex;
  2136.             }
  2137.  
  2138.             return elem.selected === true;
  2139.         },
  2140.  
  2141.         // Contents
  2142.         "empty": function( elem ) {
  2143.             // http://www.w3.org/TR/selectors/#empty-pseudo
  2144.             // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
  2145.             //   but not by others (comment: 8; processing instruction: 7; etc.)
  2146.             // nodeType < 6 works because attributes (2) do not appear as children
  2147.             for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
  2148.                 if ( elem.nodeType < 6 ) {
  2149.                     return false;
  2150.                 }
  2151.             }
  2152.             return true;
  2153.         },
  2154.  
  2155.         "parent": function( elem ) {
  2156.             return !Expr.pseudos["empty"]( elem );
  2157.         },
  2158.  
  2159.         // Element/input types
  2160.         "header": function( elem ) {
  2161.             return rheader.test( elem.nodeName );
  2162.         },
  2163.  
  2164.         "input": function( elem ) {
  2165.             return rinputs.test( elem.nodeName );
  2166.         },
  2167.  
  2168.         "button": function( elem ) {
  2169.             var name = elem.nodeName.toLowerCase();
  2170.             return name === "input" && elem.type === "button" || name === "button";
  2171.         },
  2172.  
  2173.         "text": function( elem ) {
  2174.             var attr;
  2175.             return elem.nodeName.toLowerCase() === "input" &&
  2176.                 elem.type === "text" &&
  2177.  
  2178.                 // Support: IE<8
  2179.                 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
  2180.                 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
  2181.         },
  2182.  
  2183.         // Position-in-collection
  2184.         "first": createPositionalPseudo(function() {
  2185.             return [ 0 ];
  2186.         }),
  2187.  
  2188.         "last": createPositionalPseudo(function( matchIndexes, length ) {
  2189.             return [ length - 1 ];
  2190.         }),
  2191.  
  2192.         "eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2193.             return [ argument < 0 ? argument + length : argument ];
  2194.         }),
  2195.  
  2196.         "even": createPositionalPseudo(function( matchIndexes, length ) {
  2197.             var i = 0;
  2198.             for ( ; i < length; i += 2 ) {
  2199.                 matchIndexes.push( i );
  2200.             }
  2201.             return matchIndexes;
  2202.         }),
  2203.  
  2204.         "odd": createPositionalPseudo(function( matchIndexes, length ) {
  2205.             var i = 1;
  2206.             for ( ; i < length; i += 2 ) {
  2207.                 matchIndexes.push( i );
  2208.             }
  2209.             return matchIndexes;
  2210.         }),
  2211.  
  2212.         "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2213.             var i = argument < 0 ?
  2214.                 argument + length :
  2215.                 argument > length ?
  2216.                     length :
  2217.                     argument;
  2218.             for ( ; --i >= 0; ) {
  2219.                 matchIndexes.push( i );
  2220.             }
  2221.             return matchIndexes;
  2222.         }),
  2223.  
  2224.         "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2225.             var i = argument < 0 ? argument + length : argument;
  2226.             for ( ; ++i < length; ) {
  2227.                 matchIndexes.push( i );
  2228.             }
  2229.             return matchIndexes;
  2230.         })
  2231.     }
  2232. };
  2233.  
  2234. Expr.pseudos["nth"] = Expr.pseudos["eq"];
  2235.  
  2236. // Add button/input type pseudos
  2237. for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
  2238.     Expr.pseudos[ i ] = createInputPseudo( i );
  2239. }
  2240. for ( i in { submit: true, reset: true } ) {
  2241.     Expr.pseudos[ i ] = createButtonPseudo( i );
  2242. }
  2243.  
  2244. // Easy API for creating new setFilters
  2245. function setFilters() {}
  2246. setFilters.prototype = Expr.filters = Expr.pseudos;
  2247. Expr.setFilters = new setFilters();
  2248.  
  2249. tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
  2250.     var matched, match, tokens, type,
  2251.         soFar, groups, preFilters,
  2252.         cached = tokenCache[ selector + " " ];
  2253.  
  2254.     if ( cached ) {
  2255.         return parseOnly ? 0 : cached.slice( 0 );
  2256.     }
  2257.  
  2258.     soFar = selector;
  2259.     groups = [];
  2260.     preFilters = Expr.preFilter;
  2261.  
  2262.     while ( soFar ) {
  2263.  
  2264.         // Comma and first run
  2265.         if ( !matched || (match = rcomma.exec( soFar )) ) {
  2266.             if ( match ) {
  2267.                 // Don't consume trailing commas as valid
  2268.                 soFar = soFar.slice( match[0].length ) || soFar;
  2269.             }
  2270.             groups.push( (tokens = []) );
  2271.         }
  2272.  
  2273.         matched = false;
  2274.  
  2275.         // Combinators
  2276.         if ( (match = rcombinators.exec( soFar )) ) {
  2277.             matched = match.shift();
  2278.             tokens.push({
  2279.                 value: matched,
  2280.                 // Cast descendant combinators to space
  2281.                 type: match[0].replace( rtrim, " " )
  2282.             });
  2283.             soFar = soFar.slice( matched.length );
  2284.         }
  2285.  
  2286.         // Filters
  2287.         for ( type in Expr.filter ) {
  2288.             if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
  2289.                 (match = preFilters[ type ]( match ))) ) {
  2290.                 matched = match.shift();
  2291.                 tokens.push({
  2292.                     value: matched,
  2293.                     type: type,
  2294.                     matches: match
  2295.                 });
  2296.                 soFar = soFar.slice( matched.length );
  2297.             }
  2298.         }
  2299.  
  2300.         if ( !matched ) {
  2301.             break;
  2302.         }
  2303.     }
  2304.  
  2305.     // Return the length of the invalid excess
  2306.     // if we're just parsing
  2307.     // Otherwise, throw an error or return tokens
  2308.     return parseOnly ?
  2309.         soFar.length :
  2310.         soFar ?
  2311.             Sizzle.error( selector ) :
  2312.             // Cache the tokens
  2313.             tokenCache( selector, groups ).slice( 0 );
  2314. };
  2315.  
  2316. function toSelector( tokens ) {
  2317.     var i = 0,
  2318.         len = tokens.length,
  2319.         selector = "";
  2320.     for ( ; i < len; i++ ) {
  2321.         selector += tokens[i].value;
  2322.     }
  2323.     return selector;
  2324. }
  2325.  
  2326. function addCombinator( matcher, combinator, base ) {
  2327.     var dir = combinator.dir,
  2328.         skip = combinator.next,
  2329.         key = skip || dir,
  2330.         checkNonElements = base && key === "parentNode",
  2331.         doneName = done++;
  2332.  
  2333.     return combinator.first ?
  2334.         // Check against closest ancestor/preceding element
  2335.         function( elem, context, xml ) {
  2336.             while ( (elem = elem[ dir ]) ) {
  2337.                 if ( elem.nodeType === 1 || checkNonElements ) {
  2338.                     return matcher( elem, context, xml );
  2339.                 }
  2340.             }
  2341.             return false;
  2342.         } :
  2343.  
  2344.         // Check against all ancestor/preceding elements
  2345.         function( elem, context, xml ) {
  2346.             var oldCache, uniqueCache, outerCache,
  2347.                 newCache = [ dirruns, doneName ];
  2348.  
  2349.             // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
  2350.             if ( xml ) {
  2351.                 while ( (elem = elem[ dir ]) ) {
  2352.                     if ( elem.nodeType === 1 || checkNonElements ) {
  2353.                         if ( matcher( elem, context, xml ) ) {
  2354.                             return true;
  2355.                         }
  2356.                     }
  2357.                 }
  2358.             } else {
  2359.                 while ( (elem = elem[ dir ]) ) {
  2360.                     if ( elem.nodeType === 1 || checkNonElements ) {
  2361.                         outerCache = elem[ expando ] || (elem[ expando ] = {});
  2362.  
  2363.                         // Support: IE <9 only
  2364.                         // Defend against cloned attroperties (jQuery gh-1709)
  2365.                         uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
  2366.  
  2367.                         if ( skip && skip === elem.nodeName.toLowerCase() ) {
  2368.                             elem = elem[ dir ] || elem;
  2369.                         } else if ( (oldCache = uniqueCache[ key ]) &&
  2370.                             oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
  2371.  
  2372.                             // Assign to newCache so results back-propagate to previous elements
  2373.                             return (newCache[ 2 ] = oldCache[ 2 ]);
  2374.                         } else {
  2375.                             // Reuse newcache so results back-propagate to previous elements
  2376.                             uniqueCache[ key ] = newCache;
  2377.  
  2378.                             // A match means we're done; a fail means we have to keep checking
  2379.                             if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
  2380.                                 return true;
  2381.                             }
  2382.                         }
  2383.                     }
  2384.                 }
  2385.             }
  2386.             return false;
  2387.         };
  2388. }
  2389.  
  2390. function elementMatcher( matchers ) {
  2391.     return matchers.length > 1 ?
  2392.         function( elem, context, xml ) {
  2393.             var i = matchers.length;
  2394.             while ( i-- ) {
  2395.                 if ( !matchers[i]( elem, context, xml ) ) {
  2396.                     return false;
  2397.                 }
  2398.             }
  2399.             return true;
  2400.         } :
  2401.         matchers[0];
  2402. }
  2403.  
  2404. function multipleContexts( selector, contexts, results ) {
  2405.     var i = 0,
  2406.         len = contexts.length;
  2407.     for ( ; i < len; i++ ) {
  2408.         Sizzle( selector, contexts[i], results );
  2409.     }
  2410.     return results;
  2411. }
  2412.  
  2413. function condense( unmatched, map, filter, context, xml ) {
  2414.     var elem,
  2415.         newUnmatched = [],
  2416.         i = 0,
  2417.         len = unmatched.length,
  2418.         mapped = map != null;
  2419.  
  2420.     for ( ; i < len; i++ ) {
  2421.         if ( (elem = unmatched[i]) ) {
  2422.             if ( !filter || filter( elem, context, xml ) ) {
  2423.                 newUnmatched.push( elem );
  2424.                 if ( mapped ) {
  2425.                     map.push( i );
  2426.                 }
  2427.             }
  2428.         }
  2429.     }
  2430.  
  2431.     return newUnmatched;
  2432. }
  2433.  
  2434. function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
  2435.     if ( postFilter && !postFilter[ expando ] ) {
  2436.         postFilter = setMatcher( postFilter );
  2437.     }
  2438.     if ( postFinder && !postFinder[ expando ] ) {
  2439.         postFinder = setMatcher( postFinder, postSelector );
  2440.     }
  2441.     return markFunction(function( seed, results, context, xml ) {
  2442.         var temp, i, elem,
  2443.             preMap = [],
  2444.             postMap = [],
  2445.             preexisting = results.length,
  2446.  
  2447.             // Get initial elements from seed or context
  2448.             elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
  2449.  
  2450.             // Prefilter to get matcher input, preserving a map for seed-results synchronization
  2451.             matcherIn = preFilter && ( seed || !selector ) ?
  2452.                 condense( elems, preMap, preFilter, context, xml ) :
  2453.                 elems,
  2454.  
  2455.             matcherOut = matcher ?
  2456.                 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
  2457.                 postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
  2458.  
  2459.                     // ...intermediate processing is necessary
  2460.                     [] :
  2461.  
  2462.                     // ...otherwise use results directly
  2463.                     results :
  2464.                 matcherIn;
  2465.  
  2466.         // Find primary matches
  2467.         if ( matcher ) {
  2468.             matcher( matcherIn, matcherOut, context, xml );
  2469.         }
  2470.  
  2471.         // Apply postFilter
  2472.         if ( postFilter ) {
  2473.             temp = condense( matcherOut, postMap );
  2474.             postFilter( temp, [], context, xml );
  2475.  
  2476.             // Un-match failing elements by moving them back to matcherIn
  2477.             i = temp.length;
  2478.             while ( i-- ) {
  2479.                 if ( (elem = temp[i]) ) {
  2480.                     matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
  2481.                 }
  2482.             }
  2483.         }
  2484.  
  2485.         if ( seed ) {
  2486.             if ( postFinder || preFilter ) {
  2487.                 if ( postFinder ) {
  2488.                     // Get the final matcherOut by condensing this intermediate into postFinder contexts
  2489.                     temp = [];
  2490.                     i = matcherOut.length;
  2491.                     while ( i-- ) {
  2492.                         if ( (elem = matcherOut[i]) ) {
  2493.                             // Restore matcherIn since elem is not yet a final match
  2494.                             temp.push( (matcherIn[i] = elem) );
  2495.                         }
  2496.                     }
  2497.                     postFinder( null, (matcherOut = []), temp, xml );
  2498.                 }
  2499.  
  2500.                 // Move matched elements from seed to results to keep them synchronized
  2501.                 i = matcherOut.length;
  2502.                 while ( i-- ) {
  2503.                     if ( (elem = matcherOut[i]) &&
  2504.                         (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
  2505.  
  2506.                         seed[temp] = !(results[temp] = elem);
  2507.                     }
  2508.                 }
  2509.             }
  2510.  
  2511.         // Add elements to results, through postFinder if defined
  2512.         } else {
  2513.             matcherOut = condense(
  2514.                 matcherOut === results ?
  2515.                     matcherOut.splice( preexisting, matcherOut.length ) :
  2516.                     matcherOut
  2517.             );
  2518.             if ( postFinder ) {
  2519.                 postFinder( null, results, matcherOut, xml );
  2520.             } else {
  2521.                 push.apply( results, matcherOut );
  2522.             }
  2523.         }
  2524.     });
  2525. }
  2526.  
  2527. function matcherFromTokens( tokens ) {
  2528.     var checkContext, matcher, j,
  2529.         len = tokens.length,
  2530.         leadingRelative = Expr.relative[ tokens[0].type ],
  2531.         implicitRelative = leadingRelative || Expr.relative[" "],
  2532.         i = leadingRelative ? 1 : 0,
  2533.  
  2534.         // The foundational matcher ensures that elements are reachable from top-level context(s)
  2535.         matchContext = addCombinator( function( elem ) {
  2536.             return elem === checkContext;
  2537.         }, implicitRelative, true ),
  2538.         matchAnyContext = addCombinator( function( elem ) {
  2539.             return indexOf( checkContext, elem ) > -1;
  2540.         }, implicitRelative, true ),
  2541.         matchers = [ function( elem, context, xml ) {
  2542.             var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
  2543.                 (checkContext = context).nodeType ?
  2544.                     matchContext( elem, context, xml ) :
  2545.                     matchAnyContext( elem, context, xml ) );
  2546.             // Avoid hanging onto element (issue #299)
  2547.             checkContext = null;
  2548.             return ret;
  2549.         } ];
  2550.  
  2551.     for ( ; i < len; i++ ) {
  2552.         if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
  2553.             matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
  2554.         } else {
  2555.             matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
  2556.  
  2557.             // Return special upon seeing a positional matcher
  2558.             if ( matcher[ expando ] ) {
  2559.                 // Find the next relative operator (if any) for proper handling
  2560.                 j = ++i;
  2561.                 for ( ; j < len; j++ ) {
  2562.                     if ( Expr.relative[ tokens[j].type ] ) {
  2563.                         break;
  2564.                     }
  2565.                 }
  2566.                 return setMatcher(
  2567.                     i > 1 && elementMatcher( matchers ),
  2568.                     i > 1 && toSelector(
  2569.                         // If the preceding token was a descendant combinator, insert an implicit any-element `*`
  2570.                         tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
  2571.                     ).replace( rtrim, "$1" ),
  2572.                     matcher,
  2573.                     i < j && matcherFromTokens( tokens.slice( i, j ) ),
  2574.                     j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
  2575.                     j < len && toSelector( tokens )
  2576.                 );
  2577.             }
  2578.             matchers.push( matcher );
  2579.         }
  2580.     }
  2581.  
  2582.     return elementMatcher( matchers );
  2583. }
  2584.  
  2585. function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
  2586.     var bySet = setMatchers.length > 0,
  2587.         byElement = elementMatchers.length > 0,
  2588.         superMatcher = function( seed, context, xml, results, outermost ) {
  2589.             var elem, j, matcher,
  2590.                 matchedCount = 0,
  2591.                 i = "0",
  2592.                 unmatched = seed && [],
  2593.                 setMatched = [],
  2594.                 contextBackup = outermostContext,
  2595.                 // We must always have either seed elements or outermost context
  2596.                 elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
  2597.                 // Use integer dirruns iff this is the outermost matcher
  2598.                 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
  2599.                 len = elems.length;
  2600.  
  2601.             if ( outermost ) {
  2602.                 outermostContext = context === document || context || outermost;
  2603.             }
  2604.  
  2605.             // Add elements passing elementMatchers directly to results
  2606.             // Support: IE<9, Safari
  2607.             // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
  2608.             for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
  2609.                 if ( byElement && elem ) {
  2610.                     j = 0;
  2611.                     if ( !context && elem.ownerDocument !== document ) {
  2612.                         setDocument( elem );
  2613.                         xml = !documentIsHTML;
  2614.                     }
  2615.                     while ( (matcher = elementMatchers[j++]) ) {
  2616.                         if ( matcher( elem, context || document, xml) ) {
  2617.                             results.push( elem );
  2618.                             break;
  2619.                         }
  2620.                     }
  2621.                     if ( outermost ) {
  2622.                         dirruns = dirrunsUnique;
  2623.                     }
  2624.                 }
  2625.  
  2626.                 // Track unmatched elements for set filters
  2627.                 if ( bySet ) {
  2628.                     // They will have gone through all possible matchers
  2629.                     if ( (elem = !matcher && elem) ) {
  2630.                         matchedCount--;
  2631.                     }
  2632.  
  2633.                     // Lengthen the array for every element, matched or not
  2634.                     if ( seed ) {
  2635.                         unmatched.push( elem );
  2636.                     }
  2637.                 }
  2638.             }
  2639.  
  2640.             // `i` is now the count of elements visited above, and adding it to `matchedCount`
  2641.             // makes the latter nonnegative.
  2642.             matchedCount += i;
  2643.  
  2644.             // Apply set filters to unmatched elements
  2645.             // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
  2646.             // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
  2647.             // no element matchers and no seed.
  2648.             // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
  2649.             // case, which will result in a "00" `matchedCount` that differs from `i` but is also
  2650.             // numerically zero.
  2651.             if ( bySet && i !== matchedCount ) {
  2652.                 j = 0;
  2653.                 while ( (matcher = setMatchers[j++]) ) {
  2654.                     matcher( unmatched, setMatched, context, xml );
  2655.                 }
  2656.  
  2657.                 if ( seed ) {
  2658.                     // Reintegrate element matches to eliminate the need for sorting
  2659.                     if ( matchedCount > 0 ) {
  2660.                         while ( i-- ) {
  2661.                             if ( !(unmatched[i] || setMatched[i]) ) {
  2662.                                 setMatched[i] = pop.call( results );
  2663.                             }
  2664.                         }
  2665.                     }
  2666.  
  2667.                     // Discard index placeholder values to get only actual matches
  2668.                     setMatched = condense( setMatched );
  2669.                 }
  2670.  
  2671.                 // Add matches to results
  2672.                 push.apply( results, setMatched );
  2673.  
  2674.                 // Seedless set matches succeeding multiple successful matchers stipulate sorting
  2675.                 if ( outermost && !seed && setMatched.length > 0 &&
  2676.                     ( matchedCount + setMatchers.length ) > 1 ) {
  2677.  
  2678.                     Sizzle.uniqueSort( results );
  2679.                 }
  2680.             }
  2681.  
  2682.             // Override manipulation of globals by nested matchers
  2683.             if ( outermost ) {
  2684.                 dirruns = dirrunsUnique;
  2685.                 outermostContext = contextBackup;
  2686.             }
  2687.  
  2688.             return unmatched;
  2689.         };
  2690.  
  2691.     return bySet ?
  2692.         markFunction( superMatcher ) :
  2693.         superMatcher;
  2694. }
  2695.  
  2696. compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
  2697.     var i,
  2698.         setMatchers = [],
  2699.         elementMatchers = [],
  2700.         cached = compilerCache[ selector + " " ];
  2701.  
  2702.     if ( !cached ) {
  2703.         // Generate a function of recursive functions that can be used to check each element
  2704.         if ( !match ) {
  2705.             match = tokenize( selector );
  2706.         }
  2707.         i = match.length;
  2708.         while ( i-- ) {
  2709.             cached = matcherFromTokens( match[i] );
  2710.             if ( cached[ expando ] ) {
  2711.                 setMatchers.push( cached );
  2712.             } else {
  2713.                 elementMatchers.push( cached );
  2714.             }
  2715.         }
  2716.  
  2717.         // Cache the compiled function
  2718.         cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
  2719.  
  2720.         // Save selector and tokenization
  2721.         cached.selector = selector;
  2722.     }
  2723.     return cached;
  2724. };
  2725.  
  2726. /**
  2727.  * A low-level selection function that works with Sizzle's compiled
  2728.  *  selector functions
  2729.  * @param {String|Function} selector A selector or a pre-compiled
  2730.  *  selector function built with Sizzle.compile
  2731.  * @param {Element} context
  2732.  * @param {Array} [results]
  2733.  * @param {Array} [seed] A set of elements to match against
  2734.  */
  2735. select = Sizzle.select = function( selector, context, results, seed ) {
  2736.     var i, tokens, token, type, find,
  2737.         compiled = typeof selector === "function" && selector,
  2738.         match = !seed && tokenize( (selector = compiled.selector || selector) );
  2739.  
  2740.     results = results || [];
  2741.  
  2742.     // Try to minimize operations if there is only one selector in the list and no seed
  2743.     // (the latter of which guarantees us context)
  2744.     if ( match.length === 1 ) {
  2745.  
  2746.         // Reduce context if the leading compound selector is an ID
  2747.         tokens = match[0] = match[0].slice( 0 );
  2748.         if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
  2749.                 context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
  2750.  
  2751.             context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
  2752.             if ( !context ) {
  2753.                 return results;
  2754.  
  2755.             // Precompiled matchers will still verify ancestry, so step up a level
  2756.             } else if ( compiled ) {
  2757.                 context = context.parentNode;
  2758.             }
  2759.  
  2760.             selector = selector.slice( tokens.shift().value.length );
  2761.         }
  2762.  
  2763.         // Fetch a seed set for right-to-left matching
  2764.         i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
  2765.         while ( i-- ) {
  2766.             token = tokens[i];
  2767.  
  2768.             // Abort if we hit a combinator
  2769.             if ( Expr.relative[ (type = token.type) ] ) {
  2770.                 break;
  2771.             }
  2772.             if ( (find = Expr.find[ type ]) ) {
  2773.                 // Search, expanding context for leading sibling combinators
  2774.                 if ( (seed = find(
  2775.                     token.matches[0].replace( runescape, funescape ),
  2776.                     rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
  2777.                 )) ) {
  2778.  
  2779.                     // If seed is empty or no tokens remain, we can return early
  2780.                     tokens.splice( i, 1 );
  2781.                     selector = seed.length && toSelector( tokens );
  2782.                     if ( !selector ) {
  2783.                         push.apply( results, seed );
  2784.                         return results;
  2785.                     }
  2786.  
  2787.                     break;
  2788.                 }
  2789.             }
  2790.         }
  2791.     }
  2792.  
  2793.     // Compile and execute a filtering function if one is not provided
  2794.     // Provide `match` to avoid retokenization if we modified the selector above
  2795.     ( compiled || compile( selector, match ) )(
  2796.         seed,
  2797.         context,
  2798.         !documentIsHTML,
  2799.         results,
  2800.         !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
  2801.     );
  2802.     return results;
  2803. };
  2804.  
  2805. // One-time assignments
  2806.  
  2807. // Sort stability
  2808. support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
  2809.  
  2810. // Support: Chrome 14-35+
  2811. // Always assume duplicates if they aren't passed to the comparison function
  2812. support.detectDuplicates = !!hasDuplicate;
  2813.  
  2814. // Initialize against the default document
  2815. setDocument();
  2816.  
  2817. // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
  2818. // Detached nodes confoundingly follow *each other*
  2819. support.sortDetached = assert(function( el ) {
  2820.     // Should return 1, but returns 4 (following)
  2821.     return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
  2822. });
  2823.  
  2824. // Support: IE<8
  2825. // Prevent attribute/property "interpolation"
  2826. // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
  2827. if ( !assert(function( el ) {
  2828.     el.innerHTML = "<a href='#'></a>";
  2829.     return el.firstChild.getAttribute("href") === "#" ;
  2830. }) ) {
  2831.     addHandle( "type|href|height|width", function( elem, name, isXML ) {
  2832.         if ( !isXML ) {
  2833.             return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
  2834.         }
  2835.     });
  2836. }
  2837.  
  2838. // Support: IE<9
  2839. // Use defaultValue in place of getAttribute("value")
  2840. if ( !support.attributes || !assert(function( el ) {
  2841.     el.innerHTML = "<input/>";
  2842.     el.firstChild.setAttribute( "value", "" );
  2843.     return el.firstChild.getAttribute( "value" ) === "";
  2844. }) ) {
  2845.     addHandle( "value", function( elem, name, isXML ) {
  2846.         if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
  2847.             return elem.defaultValue;
  2848.         }
  2849.     });
  2850. }
  2851.  
  2852. // Support: IE<9
  2853. // Use getAttributeNode to fetch booleans when getAttribute lies
  2854. if ( !assert(function( el ) {
  2855.     return el.getAttribute("disabled") == null;
  2856. }) ) {
  2857.     addHandle( booleans, function( elem, name, isXML ) {
  2858.         var val;
  2859.         if ( !isXML ) {
  2860.             return elem[ name ] === true ? name.toLowerCase() :
  2861.                     (val = elem.getAttributeNode( name )) && val.specified ?
  2862.                     val.value :
  2863.                 null;
  2864.         }
  2865.     });
  2866. }
  2867.  
  2868. return Sizzle;
  2869.  
  2870. })( window );
  2871.  
  2872.  
  2873.  
  2874. jQuery.find = Sizzle;
  2875. jQuery.expr = Sizzle.selectors;
  2876.  
  2877. // Deprecated
  2878. jQuery.expr[ ":" ] = jQuery.expr.pseudos;
  2879. jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
  2880. jQuery.text = Sizzle.getText;
  2881. jQuery.isXMLDoc = Sizzle.isXML;
  2882. jQuery.contains = Sizzle.contains;
  2883. jQuery.escapeSelector = Sizzle.escape;
  2884.  
  2885.  
  2886.  
  2887.  
  2888. var dir = function( elem, dir, until ) {
  2889.     var matched = [],
  2890.         truncate = until !== undefined;
  2891.  
  2892.     while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
  2893.         if ( elem.nodeType === 1 ) {
  2894.             if ( truncate && jQuery( elem ).is( until ) ) {
  2895.                 break;
  2896.             }
  2897.             matched.push( elem );
  2898.         }
  2899.     }
  2900.     return matched;
  2901. };
  2902.  
  2903.  
  2904. var siblings = function( n, elem ) {
  2905.     var matched = [];
  2906.  
  2907.     for ( ; n; n = n.nextSibling ) {
  2908.         if ( n.nodeType === 1 && n !== elem ) {
  2909.             matched.push( n );
  2910.         }
  2911.     }
  2912.  
  2913.     return matched;
  2914. };
  2915.  
  2916.  
  2917. var rneedsContext = jQuery.expr.match.needsContext;
  2918.  
  2919.  
  2920.  
  2921. function nodeName( elem, name ) {
  2922.  
  2923.   return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
  2924.  
  2925. };
  2926. var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
  2927.  
  2928.  
  2929.  
  2930. // Implement the identical functionality for filter and not
  2931. function winnow( elements, qualifier, not ) {
  2932.     if ( isFunction( qualifier ) ) {
  2933.         return jQuery.grep( elements, function( elem, i ) {
  2934.             return !!qualifier.call( elem, i, elem ) !== not;
  2935.         } );
  2936.     }
  2937.  
  2938.     // Single element
  2939.     if ( qualifier.nodeType ) {
  2940.         return jQuery.grep( elements, function( elem ) {
  2941.             return ( elem === qualifier ) !== not;
  2942.         } );
  2943.     }
  2944.  
  2945.     // Arraylike of elements (jQuery, arguments, Array)
  2946.     if ( typeof qualifier !== "string" ) {
  2947.         return jQuery.grep( elements, function( elem ) {
  2948.             return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
  2949.         } );
  2950.     }
  2951.  
  2952.     // Filtered directly for both simple and complex selectors
  2953.     return jQuery.filter( qualifier, elements, not );
  2954. }
  2955.  
  2956. jQuery.filter = function( expr, elems, not ) {
  2957.     var elem = elems[ 0 ];
  2958.  
  2959.     if ( not ) {
  2960.         expr = ":not(" + expr + ")";
  2961.     }
  2962.  
  2963.     if ( elems.length === 1 && elem.nodeType === 1 ) {
  2964.         return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
  2965.     }
  2966.  
  2967.     return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
  2968.         return elem.nodeType === 1;
  2969.     } ) );
  2970. };
  2971.  
  2972. jQuery.fn.extend( {
  2973.     find: function( selector ) {
  2974.         var i, ret,
  2975.             len = this.length,
  2976.             self = this;
  2977.  
  2978.         if ( typeof selector !== "string" ) {
  2979.             return this.pushStack( jQuery( selector ).filter( function() {
  2980.                 for ( i = 0; i < len; i++ ) {
  2981.                     if ( jQuery.contains( self[ i ], this ) ) {
  2982.                         return true;
  2983.                     }
  2984.                 }
  2985.             } ) );
  2986.         }
  2987.  
  2988.         ret = this.pushStack( [] );
  2989.  
  2990.         for ( i = 0; i < len; i++ ) {
  2991.             jQuery.find( selector, self[ i ], ret );
  2992.         }
  2993.  
  2994.         return len > 1 ? jQuery.uniqueSort( ret ) : ret;
  2995.     },
  2996.     filter: function( selector ) {
  2997.         return this.pushStack( winnow( this, selector || [], false ) );
  2998.     },
  2999.     not: function( selector ) {
  3000.         return this.pushStack( winnow( this, selector || [], true ) );
  3001.     },
  3002.     is: function( selector ) {
  3003.         return !!winnow(
  3004.             this,
  3005.  
  3006.             // If this is a positional/relative selector, check membership in the returned set
  3007.             // so $("p:first").is("p:last") won't return true for a doc with two "p".
  3008.             typeof selector === "string" && rneedsContext.test( selector ) ?
  3009.                 jQuery( selector ) :
  3010.                 selector || [],
  3011.             false
  3012.         ).length;
  3013.     }
  3014. } );
  3015.  
  3016.  
  3017. // Initialize a jQuery object
  3018.  
  3019.  
  3020. // A central reference to the root jQuery(document)
  3021. var rootjQuery,
  3022.  
  3023.     // A simple way to check for HTML strings
  3024.     // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
  3025.     // Strict HTML recognition (#11290: must start with <)
  3026.     // Shortcut simple #id case for speed
  3027.     rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
  3028.  
  3029.     init = jQuery.fn.init = function( selector, context, root ) {
  3030.         var match, elem;
  3031.  
  3032.         // HANDLE: $(""), $(null), $(undefined), $(false)
  3033.         if ( !selector ) {
  3034.             return this;
  3035.         }
  3036.  
  3037.         // Method init() accepts an alternate rootjQuery
  3038.         // so migrate can support jQuery.sub (gh-2101)
  3039.         root = root || rootjQuery;
  3040.  
  3041.         // Handle HTML strings
  3042.         if ( typeof selector === "string" ) {
  3043.             if ( selector[ 0 ] === "<" &&
  3044.                 selector[ selector.length - 1 ] === ">" &&
  3045.                 selector.length >= 3 ) {
  3046.  
  3047.                 // Assume that strings that start and end with <> are HTML and skip the regex check
  3048.                 match = [ null, selector, null ];
  3049.  
  3050.             } else {
  3051.                 match = rquickExpr.exec( selector );
  3052.             }
  3053.  
  3054.             // Match html or make sure no context is specified for #id
  3055.             if ( match && ( match[ 1 ] || !context ) ) {
  3056.  
  3057.                 // HANDLE: $(html) -> $(array)
  3058.                 if ( match[ 1 ] ) {
  3059.                     context = context instanceof jQuery ? context[ 0 ] : context;
  3060.  
  3061.                     // Option to run scripts is true for back-compat
  3062.                     // Intentionally let the error be thrown if parseHTML is not present
  3063.                     jQuery.merge( this, jQuery.parseHTML(
  3064.                         match[ 1 ],
  3065.                         context && context.nodeType ? context.ownerDocument || context : document,
  3066.                         true
  3067.                     ) );
  3068.  
  3069.                     // HANDLE: $(html, props)
  3070.                     if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
  3071.                         for ( match in context ) {
  3072.  
  3073.                             // Properties of context are called as methods if possible
  3074.                             if ( isFunction( this[ match ] ) ) {
  3075.                                 this[ match ]( context[ match ] );
  3076.  
  3077.                             // ...and otherwise set as attributes
  3078.                             } else {
  3079.                                 this.attr( match, context[ match ] );
  3080.                             }
  3081.                         }
  3082.                     }
  3083.  
  3084.                     return this;
  3085.  
  3086.                 // HANDLE: $(#id)
  3087.                 } else {
  3088.                     elem = document.getElementById( match[ 2 ] );
  3089.  
  3090.                     if ( elem ) {
  3091.  
  3092.                         // Inject the element directly into the jQuery object
  3093.                         this[ 0 ] = elem;
  3094.                         this.length = 1;
  3095.                     }
  3096.                     return this;
  3097.                 }
  3098.  
  3099.             // HANDLE: $(expr, $(...))
  3100.             } else if ( !context || context.jquery ) {
  3101.                 return ( context || root ).find( selector );
  3102.  
  3103.             // HANDLE: $(expr, context)
  3104.             // (which is just equivalent to: $(context).find(expr)
  3105.             } else {
  3106.                 return this.constructor( context ).find( selector );
  3107.             }
  3108.  
  3109.         // HANDLE: $(DOMElement)
  3110.         } else if ( selector.nodeType ) {
  3111.             this[ 0 ] = selector;
  3112.             this.length = 1;
  3113.             return this;
  3114.  
  3115.         // HANDLE: $(function)
  3116.         // Shortcut for document ready
  3117.         } else if ( isFunction( selector ) ) {
  3118.             return root.ready !== undefined ?
  3119.                 root.ready( selector ) :
  3120.  
  3121.                 // Execute immediately if ready is not present
  3122.                 selector( jQuery );
  3123.         }
  3124.  
  3125.         return jQuery.makeArray( selector, this );
  3126.     };
  3127.  
  3128. // Give the init function the jQuery prototype for later instantiation
  3129. init.prototype = jQuery.fn;
  3130.  
  3131. // Initialize central reference
  3132. rootjQuery = jQuery( document );
  3133.  
  3134.  
  3135. var rparentsprev = /^(?:parents|prev(?:Until|All))/,
  3136.  
  3137.     // Methods guaranteed to produce a unique set when starting from a unique set
  3138.     guaranteedUnique = {
  3139.         children: true,
  3140.         contents: true,
  3141.         next: true,
  3142.         prev: true
  3143.     };
  3144.  
  3145. jQuery.fn.extend( {
  3146.     has: function( target ) {
  3147.         var targets = jQuery( target, this ),
  3148.             l = targets.length;
  3149.  
  3150.         return this.filter( function() {
  3151.             var i = 0;
  3152.             for ( ; i < l; i++ ) {
  3153.                 if ( jQuery.contains( this, targets[ i ] ) ) {
  3154.                     return true;
  3155.                 }
  3156.             }
  3157.         } );
  3158.     },
  3159.  
  3160.     closest: function( selectors, context ) {
  3161.         var cur,
  3162.             i = 0,
  3163.             l = this.length,
  3164.             matched = [],
  3165.             targets = typeof selectors !== "string" && jQuery( selectors );
  3166.  
  3167.         // Positional selectors never match, since there's no _selection_ context
  3168.         if ( !rneedsContext.test( selectors ) ) {
  3169.             for ( ; i < l; i++ ) {
  3170.                 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
  3171.  
  3172.                     // Always skip document fragments
  3173.                     if ( cur.nodeType < 11 && ( targets ?
  3174.                         targets.index( cur ) > -1 :
  3175.  
  3176.                         // Don't pass non-elements to Sizzle
  3177.                         cur.nodeType === 1 &&
  3178.                             jQuery.find.matchesSelector( cur, selectors ) ) ) {
  3179.  
  3180.                         matched.push( cur );
  3181.                         break;
  3182.                     }
  3183.                 }
  3184.             }
  3185.         }
  3186.  
  3187.         return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
  3188.     },
  3189.  
  3190.     // Determine the position of an element within the set
  3191.     index: function( elem ) {
  3192.  
  3193.         // No argument, return index in parent
  3194.         if ( !elem ) {
  3195.             return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
  3196.         }
  3197.  
  3198.         // Index in selector
  3199.         if ( typeof elem === "string" ) {
  3200.             return indexOf.call( jQuery( elem ), this[ 0 ] );
  3201.         }
  3202.  
  3203.         // Locate the position of the desired element
  3204.         return indexOf.call( this,
  3205.  
  3206.             // If it receives a jQuery object, the first element is used
  3207.             elem.jquery ? elem[ 0 ] : elem
  3208.         );
  3209.     },
  3210.  
  3211.     add: function( selector, context ) {
  3212.         return this.pushStack(
  3213.             jQuery.uniqueSort(
  3214.                 jQuery.merge( this.get(), jQuery( selector, context ) )
  3215.             )
  3216.         );
  3217.     },
  3218.  
  3219.     addBack: function( selector ) {
  3220.         return this.add( selector == null ?
  3221.             this.prevObject : this.prevObject.filter( selector )
  3222.         );
  3223.     }
  3224. } );
  3225.  
  3226. function sibling( cur, dir ) {
  3227.     while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
  3228.     return cur;
  3229. }
  3230.  
  3231. jQuery.each( {
  3232.     parent: function( elem ) {
  3233.         var parent = elem.parentNode;
  3234.         return parent && parent.nodeType !== 11 ? parent : null;
  3235.     },
  3236.     parents: function( elem ) {
  3237.         return dir( elem, "parentNode" );
  3238.     },
  3239.     parentsUntil: function( elem, i, until ) {
  3240.         return dir( elem, "parentNode", until );
  3241.     },
  3242.     next: function( elem ) {
  3243.         return sibling( elem, "nextSibling" );
  3244.     },
  3245.     prev: function( elem ) {
  3246.         return sibling( elem, "previousSibling" );
  3247.     },
  3248.     nextAll: function( elem ) {
  3249.         return dir( elem, "nextSibling" );
  3250.     },
  3251.     prevAll: function( elem ) {
  3252.         return dir( elem, "previousSibling" );
  3253.     },
  3254.     nextUntil: function( elem, i, until ) {
  3255.         return dir( elem, "nextSibling", until );
  3256.     },
  3257.     prevUntil: function( elem, i, until ) {
  3258.         return dir( elem, "previousSibling", until );
  3259.     },
  3260.     siblings: function( elem ) {
  3261.         return siblings( ( elem.parentNode || {} ).firstChild, elem );
  3262.     },
  3263.     children: function( elem ) {
  3264.         return siblings( elem.firstChild );
  3265.     },
  3266.     contents: function( elem ) {
  3267.         if ( typeof elem.contentDocument !== "undefined" ) {
  3268.             return elem.contentDocument;
  3269.         }
  3270.  
  3271.         // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
  3272.         // Treat the template element as a regular one in browsers that
  3273.         // don't support it.
  3274.         if ( nodeName( elem, "template" ) ) {
  3275.             elem = elem.content || elem;
  3276.         }
  3277.  
  3278.         return jQuery.merge( [], elem.childNodes );
  3279.     }
  3280. }, function( name, fn ) {
  3281.     jQuery.fn[ name ] = function( until, selector ) {
  3282.         var matched = jQuery.map( this, fn, until );
  3283.  
  3284.         if ( name.slice( -5 ) !== "Until" ) {
  3285.             selector = until;
  3286.         }
  3287.  
  3288.         if ( selector && typeof selector === "string" ) {
  3289.             matched = jQuery.filter( selector, matched );
  3290.         }
  3291.  
  3292.         if ( this.length > 1 ) {
  3293.  
  3294.             // Remove duplicates
  3295.             if ( !guaranteedUnique[ name ] ) {
  3296.                 jQuery.uniqueSort( matched );
  3297.             }
  3298.  
  3299.             // Reverse order for parents* and prev-derivatives
  3300.             if ( rparentsprev.test( name ) ) {
  3301.                 matched.reverse();
  3302.             }
  3303.         }
  3304.  
  3305.         return this.pushStack( matched );
  3306.     };
  3307. } );
  3308. var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
  3309.  
  3310.  
  3311.  
  3312. // Convert String-formatted options into Object-formatted ones
  3313. function createOptions( options ) {
  3314.     var object = {};
  3315.     jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
  3316.         object[ flag ] = true;
  3317.     } );
  3318.     return object;
  3319. }
  3320.  
  3321. /*
  3322.  * Create a callback list using the following parameters:
  3323.  *
  3324.  *  options: an optional list of space-separated options that will change how
  3325.  *          the callback list behaves or a more traditional option object
  3326.  *
  3327.  * By default a callback list will act like an event callback list and can be
  3328.  * "fired" multiple times.
  3329.  *
  3330.  * Possible options:
  3331.  *
  3332.  *  once:           will ensure the callback list can only be fired once (like a Deferred)
  3333.  *
  3334.  *  memory:         will keep track of previous values and will call any callback added
  3335.  *                  after the list has been fired right away with the latest "memorized"
  3336.  *                  values (like a Deferred)
  3337.  *
  3338.  *  unique:         will ensure a callback can only be added once (no duplicate in the list)
  3339.  *
  3340.  *  stopOnFalse:    interrupt callings when a callback returns false
  3341.  *
  3342.  */
  3343. jQuery.Callbacks = function( options ) {
  3344.  
  3345.     // Convert options from String-formatted to Object-formatted if needed
  3346.     // (we check in cache first)
  3347.     options = typeof options === "string" ?
  3348.         createOptions( options ) :
  3349.         jQuery.extend( {}, options );
  3350.  
  3351.     var // Flag to know if list is currently firing
  3352.         firing,
  3353.  
  3354.         // Last fire value for non-forgettable lists
  3355.         memory,
  3356.  
  3357.         // Flag to know if list was already fired
  3358.         fired,
  3359.  
  3360.         // Flag to prevent firing
  3361.         locked,
  3362.  
  3363.         // Actual callback list
  3364.         list = [],
  3365.  
  3366.         // Queue of execution data for repeatable lists
  3367.         queue = [],
  3368.  
  3369.         // Index of currently firing callback (modified by add/remove as needed)
  3370.         firingIndex = -1,
  3371.  
  3372.         // Fire callbacks
  3373.         fire = function() {
  3374.  
  3375.             // Enforce single-firing
  3376.             locked = locked || options.once;
  3377.  
  3378.             // Execute callbacks for all pending executions,
  3379.             // respecting firingIndex overrides and runtime changes
  3380.             fired = firing = true;
  3381.             for ( ; queue.length; firingIndex = -1 ) {
  3382.                 memory = queue.shift();
  3383.                 while ( ++firingIndex < list.length ) {
  3384.  
  3385.                     // Run callback and check for early termination
  3386.                     if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
  3387.                         options.stopOnFalse ) {
  3388.  
  3389.                         // Jump to end and forget the data so .add doesn't re-fire
  3390.                         firingIndex = list.length;
  3391.                         memory = false;
  3392.                     }
  3393.                 }
  3394.             }
  3395.  
  3396.             // Forget the data if we're done with it
  3397.             if ( !options.memory ) {
  3398.                 memory = false;
  3399.             }
  3400.  
  3401.             firing = false;
  3402.  
  3403.             // Clean up if we're done firing for good
  3404.             if ( locked ) {
  3405.  
  3406.                 // Keep an empty list if we have data for future add calls
  3407.                 if ( memory ) {
  3408.                     list = [];
  3409.  
  3410.                 // Otherwise, this object is spent
  3411.                 } else {
  3412.                     list = "";
  3413.                 }
  3414.             }
  3415.         },
  3416.  
  3417.         // Actual Callbacks object
  3418.         self = {
  3419.  
  3420.             // Add a callback or a collection of callbacks to the list
  3421.             add: function() {
  3422.                 if ( list ) {
  3423.  
  3424.                     // If we have memory from a past run, we should fire after adding
  3425.                     if ( memory && !firing ) {
  3426.                         firingIndex = list.length - 1;
  3427.                         queue.push( memory );
  3428.                     }
  3429.  
  3430.                     ( function add( args ) {
  3431.                         jQuery.each( args, function( _, arg ) {
  3432.                             if ( isFunction( arg ) ) {
  3433.                                 if ( !options.unique || !self.has( arg ) ) {
  3434.                                     list.push( arg );
  3435.                                 }
  3436.                             } else if ( arg && arg.length && toType( arg ) !== "string" ) {
  3437.  
  3438.                                 // Inspect recursively
  3439.                                 add( arg );
  3440.                             }
  3441.                         } );
  3442.                     } )( arguments );
  3443.  
  3444.                     if ( memory && !firing ) {
  3445.                         fire();
  3446.                     }
  3447.                 }
  3448.                 return this;
  3449.             },
  3450.  
  3451.             // Remove a callback from the list
  3452.             remove: function() {
  3453.                 jQuery.each( arguments, function( _, arg ) {
  3454.                     var index;
  3455.                     while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
  3456.                         list.splice( index, 1 );
  3457.  
  3458.                         // Handle firing indexes
  3459.                         if ( index <= firingIndex ) {
  3460.                             firingIndex--;
  3461.                         }
  3462.                     }
  3463.                 } );
  3464.                 return this;
  3465.             },
  3466.  
  3467.             // Check if a given callback is in the list.
  3468.             // If no argument is given, return whether or not list has callbacks attached.
  3469.             has: function( fn ) {
  3470.                 return fn ?
  3471.                     jQuery.inArray( fn, list ) > -1 :
  3472.                     list.length > 0;
  3473.             },
  3474.  
  3475.             // Remove all callbacks from the list
  3476.             empty: function() {
  3477.                 if ( list ) {
  3478.                     list = [];
  3479.                 }
  3480.                 return this;
  3481.             },
  3482.  
  3483.             // Disable .fire and .add
  3484.             // Abort any current/pending executions
  3485.             // Clear all callbacks and values
  3486.             disable: function() {
  3487.                 locked = queue = [];
  3488.                 list = memory = "";
  3489.                 return this;
  3490.             },
  3491.             disabled: function() {
  3492.                 return !list;
  3493.             },
  3494.  
  3495.             // Disable .fire
  3496.             // Also disable .add unless we have memory (since it would have no effect)
  3497.             // Abort any pending executions
  3498.             lock: function() {
  3499.                 locked = queue = [];
  3500.                 if ( !memory && !firing ) {
  3501.                     list = memory = "";
  3502.                 }
  3503.                 return this;
  3504.             },
  3505.             locked: function() {
  3506.                 return !!locked;
  3507.             },
  3508.  
  3509.             // Call all callbacks with the given context and arguments
  3510.             fireWith: function( context, args ) {
  3511.                 if ( !locked ) {
  3512.                     args = args || [];
  3513.                     args = [ context, args.slice ? args.slice() : args ];
  3514.                     queue.push( args );
  3515.                     if ( !firing ) {
  3516.                         fire();
  3517.                     }
  3518.                 }
  3519.                 return this;
  3520.             },
  3521.  
  3522.             // Call all the callbacks with the given arguments
  3523.             fire: function() {
  3524.                 self.fireWith( this, arguments );
  3525.                 return this;
  3526.             },
  3527.  
  3528.             // To know if the callbacks have already been called at least once
  3529.             fired: function() {
  3530.                 return !!fired;
  3531.             }
  3532.         };
  3533.  
  3534.     return self;
  3535. };
  3536.  
  3537.  
  3538. function Identity( v ) {
  3539.     return v;
  3540. }
  3541. function Thrower( ex ) {
  3542.     throw ex;
  3543. }
  3544.  
  3545. function adoptValue( value, resolve, reject, noValue ) {
  3546.     var method;
  3547.  
  3548.     try {
  3549.  
  3550.         // Check for promise aspect first to privilege synchronous behavior
  3551.         if ( value && isFunction( ( method = value.promise ) ) ) {
  3552.             method.call( value ).done( resolve ).fail( reject );
  3553.  
  3554.         // Other thenables
  3555.         } else if ( value && isFunction( ( method = value.then ) ) ) {
  3556.             method.call( value, resolve, reject );
  3557.  
  3558.         // Other non-thenables
  3559.         } else {
  3560.  
  3561.             // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
  3562.             // * false: [ value ].slice( 0 ) => resolve( value )
  3563.             // * true: [ value ].slice( 1 ) => resolve()
  3564.             resolve.apply( undefined, [ value ].slice( noValue ) );
  3565.         }
  3566.  
  3567.     // For Promises/A+, convert exceptions into rejections
  3568.     // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
  3569.     // Deferred#then to conditionally suppress rejection.
  3570.     } catch ( value ) {
  3571.  
  3572.         // Support: Android 4.0 only
  3573.         // Strict mode functions invoked without .call/.apply get global-object context
  3574.         reject.apply( undefined, [ value ] );
  3575.     }
  3576. }
  3577.  
  3578. jQuery.extend( {
  3579.  
  3580.     Deferred: function( func ) {
  3581.         var tuples = [
  3582.  
  3583.                 // action, add listener, callbacks,
  3584.                 // ... .then handlers, argument index, [final state]
  3585.                 [ "notify", "progress", jQuery.Callbacks( "memory" ),
  3586.                     jQuery.Callbacks( "memory" ), 2 ],
  3587.                 [ "resolve", "done", jQuery.Callbacks( "once memory" ),
  3588.                     jQuery.Callbacks( "once memory" ), 0, "resolved" ],
  3589.                 [ "reject", "fail", jQuery.Callbacks( "once memory" ),
  3590.                     jQuery.Callbacks( "once memory" ), 1, "rejected" ]
  3591.             ],
  3592.             state = "pending",
  3593.             promise = {
  3594.                 state: function() {
  3595.                     return state;
  3596.                 },
  3597.                 always: function() {
  3598.                     deferred.done( arguments ).fail( arguments );
  3599.                     return this;
  3600.                 },
  3601.                 "catch": function( fn ) {
  3602.                     return promise.then( null, fn );
  3603.                 },
  3604.  
  3605.                 // Keep pipe for back-compat
  3606.                 pipe: function( /* fnDone, fnFail, fnProgress */ ) {
  3607.                     var fns = arguments;
  3608.  
  3609.                     return jQuery.Deferred( function( newDefer ) {
  3610.                         jQuery.each( tuples, function( i, tuple ) {
  3611.  
  3612.                             // Map tuples (progress, done, fail) to arguments (done, fail, progress)
  3613.                             var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
  3614.  
  3615.                             // deferred.progress(function() { bind to newDefer or newDefer.notify })
  3616.                             // deferred.done(function() { bind to newDefer or newDefer.resolve })
  3617.                             // deferred.fail(function() { bind to newDefer or newDefer.reject })
  3618.                             deferred[ tuple[ 1 ] ]( function() {
  3619.                                 var returned = fn && fn.apply( this, arguments );
  3620.                                 if ( returned && isFunction( returned.promise ) ) {
  3621.                                     returned.promise()
  3622.                                         .progress( newDefer.notify )
  3623.                                         .done( newDefer.resolve )
  3624.                                         .fail( newDefer.reject );
  3625.                                 } else {
  3626.                                     newDefer[ tuple[ 0 ] + "With" ](
  3627.                                         this,
  3628.                                         fn ? [ returned ] : arguments
  3629.                                     );
  3630.                                 }
  3631.                             } );
  3632.                         } );
  3633.                         fns = null;
  3634.                     } ).promise();
  3635.                 },
  3636.                 then: function( onFulfilled, onRejected, onProgress ) {
  3637.                     var maxDepth = 0;
  3638.                     function resolve( depth, deferred, handler, special ) {
  3639.                         return function() {
  3640.                             var that = this,
  3641.                                 args = arguments,
  3642.                                 mightThrow = function() {
  3643.                                     var returned, then;
  3644.  
  3645.                                     // Support: Promises/A+ section 2.3.3.3.3
  3646.                                     // https://promisesaplus.com/#point-59
  3647.                                     // Ignore double-resolution attempts
  3648.                                     if ( depth < maxDepth ) {
  3649.                                         return;
  3650.                                     }
  3651.  
  3652.                                     returned = handler.apply( that, args );
  3653.  
  3654.                                     // Support: Promises/A+ section 2.3.1
  3655.                                     // https://promisesaplus.com/#point-48
  3656.                                     if ( returned === deferred.promise() ) {
  3657.                                         throw new TypeError( "Thenable self-resolution" );
  3658.                                     }
  3659.  
  3660.                                     // Support: Promises/A+ sections 2.3.3.1, 3.5
  3661.                                     // https://promisesaplus.com/#point-54
  3662.                                     // https://promisesaplus.com/#point-75
  3663.                                     // Retrieve `then` only once
  3664.                                     then = returned &&
  3665.  
  3666.                                         // Support: Promises/A+ section 2.3.4
  3667.                                         // https://promisesaplus.com/#point-64
  3668.                                         // Only check objects and functions for thenability
  3669.                                         ( typeof returned === "object" ||
  3670.                                             typeof returned === "function" ) &&
  3671.                                         returned.then;
  3672.  
  3673.                                     // Handle a returned thenable
  3674.                                     if ( isFunction( then ) ) {
  3675.  
  3676.                                         // Special processors (notify) just wait for resolution
  3677.                                         if ( special ) {
  3678.                                             then.call(
  3679.                                                 returned,
  3680.                                                 resolve( maxDepth, deferred, Identity, special ),
  3681.                                                 resolve( maxDepth, deferred, Thrower, special )
  3682.                                             );
  3683.  
  3684.                                         // Normal processors (resolve) also hook into progress
  3685.                                         } else {
  3686.  
  3687.                                             // ...and disregard older resolution values
  3688.                                             maxDepth++;
  3689.  
  3690.                                             then.call(
  3691.                                                 returned,
  3692.                                                 resolve( maxDepth, deferred, Identity, special ),
  3693.                                                 resolve( maxDepth, deferred, Thrower, special ),
  3694.                                                 resolve( maxDepth, deferred, Identity,
  3695.                                                     deferred.notifyWith )
  3696.                                             );
  3697.                                         }
  3698.  
  3699.                                     // Handle all other returned values
  3700.                                     } else {
  3701.  
  3702.                                         // Only substitute handlers pass on context
  3703.                                         // and multiple values (non-spec behavior)
  3704.                                         if ( handler !== Identity ) {
  3705.                                             that = undefined;
  3706.                                             args = [ returned ];
  3707.                                         }
  3708.  
  3709.                                         // Process the value(s)
  3710.                                         // Default process is resolve
  3711.                                         ( special || deferred.resolveWith )( that, args );
  3712.                                     }
  3713.                                 },
  3714.  
  3715.                                 // Only normal processors (resolve) catch and reject exceptions
  3716.                                 process = special ?
  3717.                                     mightThrow :
  3718.                                     function() {
  3719.                                         try {
  3720.                                             mightThrow();
  3721.                                         } catch ( e ) {
  3722.  
  3723.                                             if ( jQuery.Deferred.exceptionHook ) {
  3724.                                                 jQuery.Deferred.exceptionHook( e,
  3725.                                                     process.stackTrace );
  3726.                                             }
  3727.  
  3728.                                             // Support: Promises/A+ section 2.3.3.3.4.1
  3729.                                             // https://promisesaplus.com/#point-61
  3730.                                             // Ignore post-resolution exceptions
  3731.                                             if ( depth + 1 >= maxDepth ) {
  3732.  
  3733.                                                 // Only substitute handlers pass on context
  3734.                                                 // and multiple values (non-spec behavior)
  3735.                                                 if ( handler !== Thrower ) {
  3736.                                                     that = undefined;
  3737.                                                     args = [ e ];
  3738.                                                 }
  3739.  
  3740.                                                 deferred.rejectWith( that, args );
  3741.                                             }
  3742.                                         }
  3743.                                     };
  3744.  
  3745.                             // Support: Promises/A+ section 2.3.3.3.1
  3746.                             // https://promisesaplus.com/#point-57
  3747.                             // Re-resolve promises immediately to dodge false rejection from
  3748.                             // subsequent errors
  3749.                             if ( depth ) {
  3750.                                 process();
  3751.                             } else {
  3752.  
  3753.                                 // Call an optional hook to record the stack, in case of exception
  3754.                                 // since it's otherwise lost when execution goes async
  3755.                                 if ( jQuery.Deferred.getStackHook ) {
  3756.                                     process.stackTrace = jQuery.Deferred.getStackHook();
  3757.                                 }
  3758.                                 window.setTimeout( process );
  3759.                             }
  3760.                         };
  3761.                     }
  3762.  
  3763.                     return jQuery.Deferred( function( newDefer ) {
  3764.  
  3765.                         // progress_handlers.add( ... )
  3766.                         tuples[ 0 ][ 3 ].add(
  3767.                             resolve(
  3768.                                 0,
  3769.                                 newDefer,
  3770.                                 isFunction( onProgress ) ?
  3771.                                     onProgress :
  3772.                                     Identity,
  3773.                                 newDefer.notifyWith
  3774.                             )
  3775.                         );
  3776.  
  3777.                         // fulfilled_handlers.add( ... )
  3778.                         tuples[ 1 ][ 3 ].add(
  3779.                             resolve(
  3780.                                 0,
  3781.                                 newDefer,
  3782.                                 isFunction( onFulfilled ) ?
  3783.                                     onFulfilled :
  3784.                                     Identity
  3785.                             )
  3786.                         );
  3787.  
  3788.                         // rejected_handlers.add( ... )
  3789.                         tuples[ 2 ][ 3 ].add(
  3790.                             resolve(
  3791.                                 0,
  3792.                                 newDefer,
  3793.                                 isFunction( onRejected ) ?
  3794.                                     onRejected :
  3795.                                     Thrower
  3796.                             )
  3797.                         );
  3798.                     } ).promise();
  3799.                 },
  3800.  
  3801.                 // Get a promise for this deferred
  3802.                 // If obj is provided, the promise aspect is added to the object
  3803.                 promise: function( obj ) {
  3804.                     return obj != null ? jQuery.extend( obj, promise ) : promise;
  3805.                 }
  3806.             },
  3807.             deferred = {};
  3808.  
  3809.         // Add list-specific methods
  3810.         jQuery.each( tuples, function( i, tuple ) {
  3811.             var list = tuple[ 2 ],
  3812.                 stateString = tuple[ 5 ];
  3813.  
  3814.             // promise.progress = list.add
  3815.             // promise.done = list.add
  3816.             // promise.fail = list.add
  3817.             promise[ tuple[ 1 ] ] = list.add;
  3818.  
  3819.             // Handle state
  3820.             if ( stateString ) {
  3821.                 list.add(
  3822.                     function() {
  3823.  
  3824.                         // state = "resolved" (i.e., fulfilled)
  3825.                         // state = "rejected"
  3826.                         state = stateString;
  3827.                     },
  3828.  
  3829.                     // rejected_callbacks.disable
  3830.                     // fulfilled_callbacks.disable
  3831.                     tuples[ 3 - i ][ 2 ].disable,
  3832.  
  3833.                     // rejected_handlers.disable
  3834.                     // fulfilled_handlers.disable
  3835.                     tuples[ 3 - i ][ 3 ].disable,
  3836.  
  3837.                     // progress_callbacks.lock
  3838.                     tuples[ 0 ][ 2 ].lock,
  3839.  
  3840.                     // progress_handlers.lock
  3841.                     tuples[ 0 ][ 3 ].lock
  3842.                 );
  3843.             }
  3844.  
  3845.             // progress_handlers.fire
  3846.             // fulfilled_handlers.fire
  3847.             // rejected_handlers.fire
  3848.             list.add( tuple[ 3 ].fire );
  3849.  
  3850.             // deferred.notify = function() { deferred.notifyWith(...) }
  3851.             // deferred.resolve = function() { deferred.resolveWith(...) }
  3852.             // deferred.reject = function() { deferred.rejectWith(...) }
  3853.             deferred[ tuple[ 0 ] ] = function() {
  3854.                 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
  3855.                 return this;
  3856.             };
  3857.  
  3858.             // deferred.notifyWith = list.fireWith
  3859.             // deferred.resolveWith = list.fireWith
  3860.             // deferred.rejectWith = list.fireWith
  3861.             deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
  3862.         } );
  3863.  
  3864.         // Make the deferred a promise
  3865.         promise.promise( deferred );
  3866.  
  3867.         // Call given func if any
  3868.         if ( func ) {
  3869.             func.call( deferred, deferred );
  3870.         }
  3871.  
  3872.         // All done!
  3873.         return deferred;
  3874.     },
  3875.  
  3876.     // Deferred helper
  3877.     when: function( singleValue ) {
  3878.         var
  3879.  
  3880.             // count of uncompleted subordinates
  3881.             remaining = arguments.length,
  3882.  
  3883.             // count of unprocessed arguments
  3884.             i = remaining,
  3885.  
  3886.             // subordinate fulfillment data
  3887.             resolveContexts = Array( i ),
  3888.             resolveValues = slice.call( arguments ),
  3889.  
  3890.             // the master Deferred
  3891.             master = jQuery.Deferred(),
  3892.  
  3893.             // subordinate callback factory
  3894.             updateFunc = function( i ) {
  3895.                 return function( value ) {
  3896.                     resolveContexts[ i ] = this;
  3897.                     resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
  3898.                     if ( !( --remaining ) ) {
  3899.                         master.resolveWith( resolveContexts, resolveValues );
  3900.                     }
  3901.                 };
  3902.             };
  3903.  
  3904.         // Single- and empty arguments are adopted like Promise.resolve
  3905.         if ( remaining <= 1 ) {
  3906.             adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
  3907.                 !remaining );
  3908.  
  3909.             // Use .then() to unwrap secondary thenables (cf. gh-3000)
  3910.             if ( master.state() === "pending" ||
  3911.                 isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
  3912.  
  3913.                 return master.then();
  3914.             }
  3915.         }
  3916.  
  3917.         // Multiple arguments are aggregated like Promise.all array elements
  3918.         while ( i-- ) {
  3919.             adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
  3920.         }
  3921.  
  3922.         return master.promise();
  3923.     }
  3924. } );
  3925.  
  3926.  
  3927. // These usually indicate a programmer mistake during development,
  3928. // warn about them ASAP rather than swallowing them by default.
  3929. var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
  3930.  
  3931. jQuery.Deferred.exceptionHook = function( error, stack ) {
  3932.  
  3933.     // Support: IE 8 - 9 only
  3934.     // Console exists when dev tools are open, which can happen at any time
  3935.     if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
  3936.         window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
  3937.     }
  3938. };
  3939.  
  3940.  
  3941.  
  3942.  
  3943. jQuery.readyException = function( error ) {
  3944.     window.setTimeout( function() {
  3945.         throw error;
  3946.     } );
  3947. };
  3948.  
  3949.  
  3950.  
  3951.  
  3952. // The deferred used on DOM ready
  3953. var readyList = jQuery.Deferred();
  3954.  
  3955. jQuery.fn.ready = function( fn ) {
  3956.  
  3957.     readyList
  3958.         .then( fn )
  3959.  
  3960.         // Wrap jQuery.readyException in a function so that the lookup
  3961.         // happens at the time of error handling instead of callback
  3962.         // registration.
  3963.         .catch( function( error ) {
  3964.             jQuery.readyException( error );
  3965.         } );
  3966.  
  3967.     return this;
  3968. };
  3969.  
  3970. jQuery.extend( {
  3971.  
  3972.     // Is the DOM ready to be used? Set to true once it occurs.
  3973.     isReady: false,
  3974.  
  3975.     // A counter to track how many items to wait for before
  3976.     // the ready event fires. See #6781
  3977.     readyWait: 1,
  3978.  
  3979.     // Handle when the DOM is ready
  3980.     ready: function( wait ) {
  3981.  
  3982.         // Abort if there are pending holds or we're already ready
  3983.         if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
  3984.             return;
  3985.         }
  3986.  
  3987.         // Remember that the DOM is ready
  3988.         jQuery.isReady = true;
  3989.  
  3990.         // If a normal DOM Ready event fired, decrement, and wait if need be
  3991.         if ( wait !== true && --jQuery.readyWait > 0 ) {
  3992.             return;
  3993.         }
  3994.  
  3995.         // If there are functions bound, to execute
  3996.         readyList.resolveWith( document, [ jQuery ] );
  3997.     }
  3998. } );
  3999.  
  4000. jQuery.ready.then = readyList.then;
  4001.  
  4002. // The ready event handler and self cleanup method
  4003. function completed() {
  4004.     document.removeEventListener( "DOMContentLoaded", completed );
  4005.     window.removeEventListener( "load", completed );
  4006.     jQuery.ready();
  4007. }
  4008.  
  4009. // Catch cases where $(document).ready() is called
  4010. // after the browser event has already occurred.
  4011. // Support: IE <=9 - 10 only
  4012. // Older IE sometimes signals "interactive" too soon
  4013. if ( document.readyState === "complete" ||
  4014.     ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
  4015.  
  4016.     // Handle it asynchronously to allow scripts the opportunity to delay ready
  4017.     window.setTimeout( jQuery.ready );
  4018.  
  4019. } else {
  4020.  
  4021.     // Use the handy event callback
  4022.     document.addEventListener( "DOMContentLoaded", completed );
  4023.  
  4024.     // A fallback to window.onload, that will always work
  4025.     window.addEventListener( "load", completed );
  4026. }
  4027.  
  4028.  
  4029.  
  4030.  
  4031. // Multifunctional method to get and set values of a collection
  4032. // The value/s can optionally be executed if it's a function
  4033. var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
  4034.     var i = 0,
  4035.         len = elems.length,
  4036.         bulk = key == null;
  4037.  
  4038.     // Sets many values
  4039.     if ( toType( key ) === "object" ) {
  4040.         chainable = true;
  4041.         for ( i in key ) {
  4042.             access( elems, fn, i, key[ i ], true, emptyGet, raw );
  4043.         }
  4044.  
  4045.     // Sets one value
  4046.     } else if ( value !== undefined ) {
  4047.         chainable = true;
  4048.  
  4049.         if ( !isFunction( value ) ) {
  4050.             raw = true;
  4051.         }
  4052.  
  4053.         if ( bulk ) {
  4054.  
  4055.             // Bulk operations run against the entire set
  4056.             if ( raw ) {
  4057.                 fn.call( elems, value );
  4058.                 fn = null;
  4059.  
  4060.             // ...except when executing function values
  4061.             } else {
  4062.                 bulk = fn;
  4063.                 fn = function( elem, key, value ) {
  4064.                     return bulk.call( jQuery( elem ), value );
  4065.                 };
  4066.             }
  4067.         }
  4068.  
  4069.         if ( fn ) {
  4070.             for ( ; i < len; i++ ) {
  4071.                 fn(
  4072.                     elems[ i ], key, raw ?
  4073.                     value :
  4074.                     value.call( elems[ i ], i, fn( elems[ i ], key ) )
  4075.                 );
  4076.             }
  4077.         }
  4078.     }
  4079.  
  4080.     if ( chainable ) {
  4081.         return elems;
  4082.     }
  4083.  
  4084.     // Gets
  4085.     if ( bulk ) {
  4086.         return fn.call( elems );
  4087.     }
  4088.  
  4089.     return len ? fn( elems[ 0 ], key ) : emptyGet;
  4090. };
  4091.  
  4092.  
  4093. // Matches dashed string for camelizing
  4094. var rmsPrefix = /^-ms-/,
  4095.     rdashAlpha = /-([a-z])/g;
  4096.  
  4097. // Used by camelCase as callback to replace()
  4098. function fcamelCase( all, letter ) {
  4099.     return letter.toUpperCase();
  4100. }
  4101.  
  4102. // Convert dashed to camelCase; used by the css and data modules
  4103. // Support: IE <=9 - 11, Edge 12 - 15
  4104. // Microsoft forgot to hump their vendor prefix (#9572)
  4105. function camelCase( string ) {
  4106.     return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
  4107. }
  4108. var acceptData = function( owner ) {
  4109.  
  4110.     // Accepts only:
  4111.     //  - Node
  4112.     //    - Node.ELEMENT_NODE
  4113.     //    - Node.DOCUMENT_NODE
  4114.     //  - Object
  4115.     //    - Any
  4116.     return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
  4117. };
  4118.  
  4119.  
  4120.  
  4121.  
  4122. function Data() {
  4123.     this.expando = jQuery.expando + Data.uid++;
  4124. }
  4125.  
  4126. Data.uid = 1;
  4127.  
  4128. Data.prototype = {
  4129.  
  4130.     cache: function( owner ) {
  4131.  
  4132.         // Check if the owner object already has a cache
  4133.         var value = owner[ this.expando ];
  4134.  
  4135.         // If not, create one
  4136.         if ( !value ) {
  4137.             value = {};
  4138.  
  4139.             // We can accept data for non-element nodes in modern browsers,
  4140.             // but we should not, see #8335.
  4141.             // Always return an empty object.
  4142.             if ( acceptData( owner ) ) {
  4143.  
  4144.                 // If it is a node unlikely to be stringify-ed or looped over
  4145.                 // use plain assignment
  4146.                 if ( owner.nodeType ) {
  4147.                     owner[ this.expando ] = value;
  4148.  
  4149.                 // Otherwise secure it in a non-enumerable property
  4150.                 // configurable must be true to allow the property to be
  4151.                 // deleted when data is removed
  4152.                 } else {
  4153.                     Object.defineProperty( owner, this.expando, {
  4154.                         value: value,
  4155.                         configurable: true
  4156.                     } );
  4157.                 }
  4158.             }
  4159.         }
  4160.  
  4161.         return value;
  4162.     },
  4163.     set: function( owner, data, value ) {
  4164.         var prop,
  4165.             cache = this.cache( owner );
  4166.  
  4167.         // Handle: [ owner, key, value ] args
  4168.         // Always use camelCase key (gh-2257)
  4169.         if ( typeof data === "string" ) {
  4170.             cache[ camelCase( data ) ] = value;
  4171.  
  4172.         // Handle: [ owner, { properties } ] args
  4173.         } else {
  4174.  
  4175.             // Copy the properties one-by-one to the cache object
  4176.             for ( prop in data ) {
  4177.                 cache[ camelCase( prop ) ] = data[ prop ];
  4178.             }
  4179.         }
  4180.         return cache;
  4181.     },
  4182.     get: function( owner, key ) {
  4183.         return key === undefined ?
  4184.             this.cache( owner ) :
  4185.  
  4186.             // Always use camelCase key (gh-2257)
  4187.             owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
  4188.     },
  4189.     access: function( owner, key, value ) {
  4190.  
  4191.         // In cases where either:
  4192.         //
  4193.         //   1. No key was specified
  4194.         //   2. A string key was specified, but no value provided
  4195.         //
  4196.         // Take the "read" path and allow the get method to determine
  4197.         // which value to return, respectively either:
  4198.         //
  4199.         //   1. The entire cache object
  4200.         //   2. The data stored at the key
  4201.         //
  4202.         if ( key === undefined ||
  4203.                 ( ( key && typeof key === "string" ) && value === undefined ) ) {
  4204.  
  4205.             return this.get( owner, key );
  4206.         }
  4207.  
  4208.         // When the key is not a string, or both a key and value
  4209.         // are specified, set or extend (existing objects) with either:
  4210.         //
  4211.         //   1. An object of properties
  4212.         //   2. A key and value
  4213.         //
  4214.         this.set( owner, key, value );
  4215.  
  4216.         // Since the "set" path can have two possible entry points
  4217.         // return the expected data based on which path was taken[*]
  4218.         return value !== undefined ? value : key;
  4219.     },
  4220.     remove: function( owner, key ) {
  4221.         var i,
  4222.             cache = owner[ this.expando ];
  4223.  
  4224.         if ( cache === undefined ) {
  4225.             return;
  4226.         }
  4227.  
  4228.         if ( key !== undefined ) {
  4229.  
  4230.             // Support array or space separated string of keys
  4231.             if ( Array.isArray( key ) ) {
  4232.  
  4233.                 // If key is an array of keys...
  4234.                 // We always set camelCase keys, so remove that.
  4235.                 key = key.map( camelCase );
  4236.             } else {
  4237.                 key = camelCase( key );
  4238.  
  4239.                 // If a key with the spaces exists, use it.
  4240.                 // Otherwise, create an array by matching non-whitespace
  4241.                 key = key in cache ?
  4242.                     [ key ] :
  4243.                     ( key.match( rnothtmlwhite ) || [] );
  4244.             }
  4245.  
  4246.             i = key.length;
  4247.  
  4248.             while ( i-- ) {
  4249.                 delete cache[ key[ i ] ];
  4250.             }
  4251.         }
  4252.  
  4253.         // Remove the expando if there's no more data
  4254.         if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
  4255.  
  4256.             // Support: Chrome <=35 - 45
  4257.             // Webkit & Blink performance suffers when deleting properties
  4258.             // from DOM nodes, so set to undefined instead
  4259.             // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
  4260.             if ( owner.nodeType ) {
  4261.                 owner[ this.expando ] = undefined;
  4262.             } else {
  4263.                 delete owner[ this.expando ];
  4264.             }
  4265.         }
  4266.     },
  4267.     hasData: function( owner ) {
  4268.         var cache = owner[ this.expando ];
  4269.         return cache !== undefined && !jQuery.isEmptyObject( cache );
  4270.     }
  4271. };
  4272. var dataPriv = new Data();
  4273.  
  4274. var dataUser = new Data();
  4275.  
  4276.  
  4277.  
  4278. //  Implementation Summary
  4279. //
  4280. //  1. Enforce API surface and semantic compatibility with 1.9.x branch
  4281. //  2. Improve the module's maintainability by reducing the storage
  4282. //      paths to a single mechanism.
  4283. //  3. Use the same single mechanism to support "private" and "user" data.
  4284. //  4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
  4285. //  5. Avoid exposing implementation details on user objects (eg. expando properties)
  4286. //  6. Provide a clear path for implementation upgrade to WeakMap in 2014
  4287.  
  4288. var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
  4289.     rmultiDash = /[A-Z]/g;
  4290.  
  4291. function getData( data ) {
  4292.     if ( data === "true" ) {
  4293.         return true;
  4294.     }
  4295.  
  4296.     if ( data === "false" ) {
  4297.         return false;
  4298.     }
  4299.  
  4300.     if ( data === "null" ) {
  4301.         return null;
  4302.     }
  4303.  
  4304.     // Only convert to a number if it doesn't change the string
  4305.     if ( data === +data + "" ) {
  4306.         return +data;
  4307.     }
  4308.  
  4309.     if ( rbrace.test( data ) ) {
  4310.         return JSON.parse( data );
  4311.     }
  4312.  
  4313.     return data;
  4314. }
  4315.  
  4316. function dataAttr( elem, key, data ) {
  4317.     var name;
  4318.  
  4319.     // If nothing was found internally, try to fetch any
  4320.     // data from the HTML5 data-* attribute
  4321.     if ( data === undefined && elem.nodeType === 1 ) {
  4322.         name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
  4323.         data = elem.getAttribute( name );
  4324.  
  4325.         if ( typeof data === "string" ) {
  4326.             try {
  4327.                 data = getData( data );
  4328.             } catch ( e ) {}
  4329.  
  4330.             // Make sure we set the data so it isn't changed later
  4331.             dataUser.set( elem, key, data );
  4332.         } else {
  4333.             data = undefined;
  4334.         }
  4335.     }
  4336.     return data;
  4337. }
  4338.  
  4339. jQuery.extend( {
  4340.     hasData: function( elem ) {
  4341.         return dataUser.hasData( elem ) || dataPriv.hasData( elem );
  4342.     },
  4343.  
  4344.     data: function( elem, name, data ) {
  4345.         return dataUser.access( elem, name, data );
  4346.     },
  4347.  
  4348.     removeData: function( elem, name ) {
  4349.         dataUser.remove( elem, name );
  4350.     },
  4351.  
  4352.     // TODO: Now that all calls to _data and _removeData have been replaced
  4353.     // with direct calls to dataPriv methods, these can be deprecated.
  4354.     _data: function( elem, name, data ) {
  4355.         return dataPriv.access( elem, name, data );
  4356.     },
  4357.  
  4358.     _removeData: function( elem, name ) {
  4359.         dataPriv.remove( elem, name );
  4360.     }
  4361. } );
  4362.  
  4363. jQuery.fn.extend( {
  4364.     data: function( key, value ) {
  4365.         var i, name, data,
  4366.             elem = this[ 0 ],
  4367.             attrs = elem && elem.attributes;
  4368.  
  4369.         // Gets all values
  4370.         if ( key === undefined ) {
  4371.             if ( this.length ) {
  4372.                 data = dataUser.get( elem );
  4373.  
  4374.                 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
  4375.                     i = attrs.length;
  4376.                     while ( i-- ) {
  4377.  
  4378.                         // Support: IE 11 only
  4379.                         // The attrs elements can be null (#14894)
  4380.                         if ( attrs[ i ] ) {
  4381.                             name = attrs[ i ].name;
  4382.                             if ( name.indexOf( "data-" ) === 0 ) {
  4383.                                 name = camelCase( name.slice( 5 ) );
  4384.                                 dataAttr( elem, name, data[ name ] );
  4385.                             }
  4386.                         }
  4387.                     }
  4388.                     dataPriv.set( elem, "hasDataAttrs", true );
  4389.                 }
  4390.             }
  4391.  
  4392.             return data;
  4393.         }
  4394.  
  4395.         // Sets multiple values
  4396.         if ( typeof key === "object" ) {
  4397.             return this.each( function() {
  4398.                 dataUser.set( this, key );
  4399.             } );
  4400.         }
  4401.  
  4402.         return access( this, function( value ) {
  4403.             var data;
  4404.  
  4405.             // The calling jQuery object (element matches) is not empty
  4406.             // (and therefore has an element appears at this[ 0 ]) and the
  4407.             // `value` parameter was not undefined. An empty jQuery object
  4408.             // will result in `undefined` for elem = this[ 0 ] which will
  4409.             // throw an exception if an attempt to read a data cache is made.
  4410.             if ( elem && value === undefined ) {
  4411.  
  4412.                 // Attempt to get data from the cache
  4413.                 // The key will always be camelCased in Data
  4414.                 data = dataUser.get( elem, key );
  4415.                 if ( data !== undefined ) {
  4416.                     return data;
  4417.                 }
  4418.  
  4419.                 // Attempt to "discover" the data in
  4420.                 // HTML5 custom data-* attrs
  4421.                 data = dataAttr( elem, key );
  4422.                 if ( data !== undefined ) {
  4423.                     return data;
  4424.                 }
  4425.  
  4426.                 // We tried really hard, but the data doesn't exist.
  4427.                 return;
  4428.             }
  4429.  
  4430.             // Set the data...
  4431.             this.each( function() {
  4432.  
  4433.                 // We always store the camelCased key
  4434.                 dataUser.set( this, key, value );
  4435.             } );
  4436.         }, null, value, arguments.length > 1, null, true );
  4437.     },
  4438.  
  4439.     removeData: function( key ) {
  4440.         return this.each( function() {
  4441.             dataUser.remove( this, key );
  4442.         } );
  4443.     }
  4444. } );
  4445.  
  4446.  
  4447. jQuery.extend( {
  4448.     queue: function( elem, type, data ) {
  4449.         var queue;
  4450.  
  4451.         if ( elem ) {
  4452.             type = ( type || "fx" ) + "queue";
  4453.             queue = dataPriv.get( elem, type );
  4454.  
  4455.             // Speed up dequeue by getting out quickly if this is just a lookup
  4456.             if ( data ) {
  4457.                 if ( !queue || Array.isArray( data ) ) {
  4458.                     queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
  4459.                 } else {
  4460.                     queue.push( data );
  4461.                 }
  4462.             }
  4463.             return queue || [];
  4464.         }
  4465.     },
  4466.  
  4467.     dequeue: function( elem, type ) {
  4468.         type = type || "fx";
  4469.  
  4470.         var queue = jQuery.queue( elem, type ),
  4471.             startLength = queue.length,
  4472.             fn = queue.shift(),
  4473.             hooks = jQuery._queueHooks( elem, type ),
  4474.             next = function() {
  4475.                 jQuery.dequeue( elem, type );
  4476.             };
  4477.  
  4478.         // If the fx queue is dequeued, always remove the progress sentinel
  4479.         if ( fn === "inprogress" ) {
  4480.             fn = queue.shift();
  4481.             startLength--;
  4482.         }
  4483.  
  4484.         if ( fn ) {
  4485.  
  4486.             // Add a progress sentinel to prevent the fx queue from being
  4487.             // automatically dequeued
  4488.             if ( type === "fx" ) {
  4489.                 queue.unshift( "inprogress" );
  4490.             }
  4491.  
  4492.             // Clear up the last queue stop function
  4493.             delete hooks.stop;
  4494.             fn.call( elem, next, hooks );
  4495.         }
  4496.  
  4497.         if ( !startLength && hooks ) {
  4498.             hooks.empty.fire();
  4499.         }
  4500.     },
  4501.  
  4502.     // Not public - generate a queueHooks object, or return the current one
  4503.     _queueHooks: function( elem, type ) {
  4504.         var key = type + "queueHooks";
  4505.         return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
  4506.             empty: jQuery.Callbacks( "once memory" ).add( function() {
  4507.                 dataPriv.remove( elem, [ type + "queue", key ] );
  4508.             } )
  4509.         } );
  4510.     }
  4511. } );
  4512.  
  4513. jQuery.fn.extend( {
  4514.     queue: function( type, data ) {
  4515.         var setter = 2;
  4516.  
  4517.         if ( typeof type !== "string" ) {
  4518.             data = type;
  4519.             type = "fx";
  4520.             setter--;
  4521.         }
  4522.  
  4523.         if ( arguments.length < setter ) {
  4524.             return jQuery.queue( this[ 0 ], type );
  4525.         }
  4526.  
  4527.         return data === undefined ?
  4528.             this :
  4529.             this.each( function() {
  4530.                 var queue = jQuery.queue( this, type, data );
  4531.  
  4532.                 // Ensure a hooks for this queue
  4533.                 jQuery._queueHooks( this, type );
  4534.  
  4535.                 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
  4536.                     jQuery.dequeue( this, type );
  4537.                 }
  4538.             } );
  4539.     },
  4540.     dequeue: function( type ) {
  4541.         return this.each( function() {
  4542.             jQuery.dequeue( this, type );
  4543.         } );
  4544.     },
  4545.     clearQueue: function( type ) {
  4546.         return this.queue( type || "fx", [] );
  4547.     },
  4548.  
  4549.     // Get a promise resolved when queues of a certain type
  4550.     // are emptied (fx is the type by default)
  4551.     promise: function( type, obj ) {
  4552.         var tmp,
  4553.             count = 1,
  4554.             defer = jQuery.Deferred(),
  4555.             elements = this,
  4556.             i = this.length,
  4557.             resolve = function() {
  4558.                 if ( !( --count ) ) {
  4559.                     defer.resolveWith( elements, [ elements ] );
  4560.                 }
  4561.             };
  4562.  
  4563.         if ( typeof type !== "string" ) {
  4564.             obj = type;
  4565.             type = undefined;
  4566.         }
  4567.         type = type || "fx";
  4568.  
  4569.         while ( i-- ) {
  4570.             tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
  4571.             if ( tmp && tmp.empty ) {
  4572.                 count++;
  4573.                 tmp.empty.add( resolve );
  4574.             }
  4575.         }
  4576.         resolve();
  4577.         return defer.promise( obj );
  4578.     }
  4579. } );
  4580. var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
  4581.  
  4582. var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
  4583.  
  4584.  
  4585. var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
  4586.  
  4587. var documentElement = document.documentElement;
  4588.  
  4589.  
  4590.  
  4591.     var isAttached = function( elem ) {
  4592.             return jQuery.contains( elem.ownerDocument, elem );
  4593.         },
  4594.         composed = { composed: true };
  4595.  
  4596.     // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
  4597.     // Check attachment across shadow DOM boundaries when possible (gh-3504)
  4598.     // Support: iOS 10.0-10.2 only
  4599.     // Early iOS 10 versions support `attachShadow` but not `getRootNode`,
  4600.     // leading to errors. We need to check for `getRootNode`.
  4601.     if ( documentElement.getRootNode ) {
  4602.         isAttached = function( elem ) {
  4603.             return jQuery.contains( elem.ownerDocument, elem ) ||
  4604.                 elem.getRootNode( composed ) === elem.ownerDocument;
  4605.         };
  4606.     }
  4607. var isHiddenWithinTree = function( elem, el ) {
  4608.  
  4609.         // isHiddenWithinTree might be called from jQuery#filter function;
  4610.         // in that case, element will be second argument
  4611.         elem = el || elem;
  4612.  
  4613.         // Inline style trumps all
  4614.         return elem.style.display === "none" ||
  4615.             elem.style.display === "" &&
  4616.  
  4617.             // Otherwise, check computed style
  4618.             // Support: Firefox <=43 - 45
  4619.             // Disconnected elements can have computed display: none, so first confirm that elem is
  4620.             // in the document.
  4621.             isAttached( elem ) &&
  4622.  
  4623.             jQuery.css( elem, "display" ) === "none";
  4624.     };
  4625.  
  4626. var swap = function( elem, options, callback, args ) {
  4627.     var ret, name,
  4628.         old = {};
  4629.  
  4630.     // Remember the old values, and insert the new ones
  4631.     for ( name in options ) {
  4632.         old[ name ] = elem.style[ name ];
  4633.         elem.style[ name ] = options[ name ];
  4634.     }
  4635.  
  4636.     ret = callback.apply( elem, args || [] );
  4637.  
  4638.     // Revert the old values
  4639.     for ( name in options ) {
  4640.         elem.style[ name ] = old[ name ];
  4641.     }
  4642.  
  4643.     return ret;
  4644. };
  4645.  
  4646.  
  4647.  
  4648.  
  4649. function adjustCSS( elem, prop, valueParts, tween ) {
  4650.     var adjusted, scale,
  4651.         maxIterations = 20,
  4652.         currentValue = tween ?
  4653.             function() {
  4654.                 return tween.cur();
  4655.             } :
  4656.             function() {
  4657.                 return jQuery.css( elem, prop, "" );
  4658.             },
  4659.         initial = currentValue(),
  4660.         unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
  4661.  
  4662.         // Starting value computation is required for potential unit mismatches
  4663.         initialInUnit = elem.nodeType &&
  4664.             ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
  4665.             rcssNum.exec( jQuery.css( elem, prop ) );
  4666.  
  4667.     if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
  4668.  
  4669.         // Support: Firefox <=54
  4670.         // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
  4671.         initial = initial / 2;
  4672.  
  4673.         // Trust units reported by jQuery.css
  4674.         unit = unit || initialInUnit[ 3 ];
  4675.  
  4676.         // Iteratively approximate from a nonzero starting point
  4677.         initialInUnit = +initial || 1;
  4678.  
  4679.         while ( maxIterations-- ) {
  4680.  
  4681.             // Evaluate and update our best guess (doubling guesses that zero out).
  4682.             // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
  4683.             jQuery.style( elem, prop, initialInUnit + unit );
  4684.             if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
  4685.                 maxIterations = 0;
  4686.             }
  4687.             initialInUnit = initialInUnit / scale;
  4688.  
  4689.         }
  4690.  
  4691.         initialInUnit = initialInUnit * 2;
  4692.         jQuery.style( elem, prop, initialInUnit + unit );
  4693.  
  4694.         // Make sure we update the tween properties later on
  4695.         valueParts = valueParts || [];
  4696.     }
  4697.  
  4698.     if ( valueParts ) {
  4699.         initialInUnit = +initialInUnit || +initial || 0;
  4700.  
  4701.         // Apply relative offset (+=/-=) if specified
  4702.         adjusted = valueParts[ 1 ] ?
  4703.             initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
  4704.             +valueParts[ 2 ];
  4705.         if ( tween ) {
  4706.             tween.unit = unit;
  4707.             tween.start = initialInUnit;
  4708.             tween.end = adjusted;
  4709.         }
  4710.     }
  4711.     return adjusted;
  4712. }
  4713.  
  4714.  
  4715. var defaultDisplayMap = {};
  4716.  
  4717. function getDefaultDisplay( elem ) {
  4718.     var temp,
  4719.         doc = elem.ownerDocument,
  4720.         nodeName = elem.nodeName,
  4721.         display = defaultDisplayMap[ nodeName ];
  4722.  
  4723.     if ( display ) {
  4724.         return display;
  4725.     }
  4726.  
  4727.     temp = doc.body.appendChild( doc.createElement( nodeName ) );
  4728.     display = jQuery.css( temp, "display" );
  4729.  
  4730.     temp.parentNode.removeChild( temp );
  4731.  
  4732.     if ( display === "none" ) {
  4733.         display = "block";
  4734.     }
  4735.     defaultDisplayMap[ nodeName ] = display;
  4736.  
  4737.     return display;
  4738. }
  4739.  
  4740. function showHide( elements, show ) {
  4741.     var display, elem,
  4742.         values = [],
  4743.         index = 0,
  4744.         length = elements.length;
  4745.  
  4746.     // Determine new display value for elements that need to change
  4747.     for ( ; index < length; index++ ) {
  4748.         elem = elements[ index ];
  4749.         if ( !elem.style ) {
  4750.             continue;
  4751.         }
  4752.  
  4753.         display = elem.style.display;
  4754.         if ( show ) {
  4755.  
  4756.             // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
  4757.             // check is required in this first loop unless we have a nonempty display value (either
  4758.             // inline or about-to-be-restored)
  4759.             if ( display === "none" ) {
  4760.                 values[ index ] = dataPriv.get( elem, "display" ) || null;
  4761.                 if ( !values[ index ] ) {
  4762.                     elem.style.display = "";
  4763.                 }
  4764.             }
  4765.             if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
  4766.                 values[ index ] = getDefaultDisplay( elem );
  4767.             }
  4768.         } else {
  4769.             if ( display !== "none" ) {
  4770.                 values[ index ] = "none";
  4771.  
  4772.                 // Remember what we're overwriting
  4773.                 dataPriv.set( elem, "display", display );
  4774.             }
  4775.         }
  4776.     }
  4777.  
  4778.     // Set the display of the elements in a second loop to avoid constant reflow
  4779.     for ( index = 0; index < length; index++ ) {
  4780.         if ( values[ index ] != null ) {
  4781.             elements[ index ].style.display = values[ index ];
  4782.         }
  4783.     }
  4784.  
  4785.     return elements;
  4786. }
  4787.  
  4788. jQuery.fn.extend( {
  4789.     show: function() {
  4790.         return showHide( this, true );
  4791.     },
  4792.     hide: function() {
  4793.         return showHide( this );
  4794.     },
  4795.     toggle: function( state ) {
  4796.         if ( typeof state === "boolean" ) {
  4797.             return state ? this.show() : this.hide();
  4798.         }
  4799.  
  4800.         return this.each( function() {
  4801.             if ( isHiddenWithinTree( this ) ) {
  4802.                 jQuery( this ).show();
  4803.             } else {
  4804.                 jQuery( this ).hide();
  4805.             }
  4806.         } );
  4807.     }
  4808. } );
  4809. var rcheckableType = ( /^(?:checkbox|radio)$/i );
  4810.  
  4811. var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
  4812.  
  4813. var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
  4814.  
  4815.  
  4816.  
  4817. // We have to close these tags to support XHTML (#13200)
  4818. var wrapMap = {
  4819.  
  4820.     // Support: IE <=9 only
  4821.     option: [ 1, "<select multiple='multiple'>", "</select>" ],
  4822.  
  4823.     // XHTML parsers do not magically insert elements in the
  4824.     // same way that tag soup parsers do. So we cannot shorten
  4825.     // this by omitting <tbody> or other required elements.
  4826.     thead: [ 1, "<table>", "</table>" ],
  4827.     col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
  4828.     tr: [ 2, "<table><tbody>", "</tbody></table>" ],
  4829.     td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
  4830.  
  4831.     _default: [ 0, "", "" ]
  4832. };
  4833.  
  4834. // Support: IE <=9 only
  4835. wrapMap.optgroup = wrapMap.option;
  4836.  
  4837. wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  4838. wrapMap.th = wrapMap.td;
  4839.  
  4840.  
  4841. function getAll( context, tag ) {
  4842.  
  4843.     // Support: IE <=9 - 11 only
  4844.     // Use typeof to avoid zero-argument method invocation on host objects (#15151)
  4845.     var ret;
  4846.  
  4847.     if ( typeof context.getElementsByTagName !== "undefined" ) {
  4848.         ret = context.getElementsByTagName( tag || "*" );
  4849.  
  4850.     } else if ( typeof context.querySelectorAll !== "undefined" ) {
  4851.         ret = context.querySelectorAll( tag || "*" );
  4852.  
  4853.     } else {
  4854.         ret = [];
  4855.     }
  4856.  
  4857.     if ( tag === undefined || tag && nodeName( context, tag ) ) {
  4858.         return jQuery.merge( [ context ], ret );
  4859.     }
  4860.  
  4861.     return ret;
  4862. }
  4863.  
  4864.  
  4865. // Mark scripts as having already been evaluated
  4866. function setGlobalEval( elems, refElements ) {
  4867.     var i = 0,
  4868.         l = elems.length;
  4869.  
  4870.     for ( ; i < l; i++ ) {
  4871.         dataPriv.set(
  4872.             elems[ i ],
  4873.             "globalEval",
  4874.             !refElements || dataPriv.get( refElements[ i ], "globalEval" )
  4875.         );
  4876.     }
  4877. }
  4878.  
  4879.  
  4880. var rhtml = /<|&#?\w+;/;
  4881.  
  4882. function buildFragment( elems, context, scripts, selection, ignored ) {
  4883.     var elem, tmp, tag, wrap, attached, j,
  4884.         fragment = context.createDocumentFragment(),
  4885.         nodes = [],
  4886.         i = 0,
  4887.         l = elems.length;
  4888.  
  4889.     for ( ; i < l; i++ ) {
  4890.         elem = elems[ i ];
  4891.  
  4892.         if ( elem || elem === 0 ) {
  4893.  
  4894.             // Add nodes directly
  4895.             if ( toType( elem ) === "object" ) {
  4896.  
  4897.                 // Support: Android <=4.0 only, PhantomJS 1 only
  4898.                 // push.apply(_, arraylike) throws on ancient WebKit
  4899.                 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
  4900.  
  4901.             // Convert non-html into a text node
  4902.             } else if ( !rhtml.test( elem ) ) {
  4903.                 nodes.push( context.createTextNode( elem ) );
  4904.  
  4905.             // Convert html into DOM nodes
  4906.             } else {
  4907.                 tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
  4908.  
  4909.                 // Deserialize a standard representation
  4910.                 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
  4911.                 wrap = wrapMap[ tag ] || wrapMap._default;
  4912.                 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
  4913.  
  4914.                 // Descend through wrappers to the right content
  4915.                 j = wrap[ 0 ];
  4916.                 while ( j-- ) {
  4917.                     tmp = tmp.lastChild;
  4918.                 }
  4919.  
  4920.                 // Support: Android <=4.0 only, PhantomJS 1 only
  4921.                 // push.apply(_, arraylike) throws on ancient WebKit
  4922.                 jQuery.merge( nodes, tmp.childNodes );
  4923.  
  4924.                 // Remember the top-level container
  4925.                 tmp = fragment.firstChild;
  4926.  
  4927.                 // Ensure the created nodes are orphaned (#12392)
  4928.                 tmp.textContent = "";
  4929.             }
  4930.         }
  4931.     }
  4932.  
  4933.     // Remove wrapper from fragment
  4934.     fragment.textContent = "";
  4935.  
  4936.     i = 0;
  4937.     while ( ( elem = nodes[ i++ ] ) ) {
  4938.  
  4939.         // Skip elements already in the context collection (trac-4087)
  4940.         if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
  4941.             if ( ignored ) {
  4942.                 ignored.push( elem );
  4943.             }
  4944.             continue;
  4945.         }
  4946.  
  4947.         attached = isAttached( elem );
  4948.  
  4949.         // Append to fragment
  4950.         tmp = getAll( fragment.appendChild( elem ), "script" );
  4951.  
  4952.         // Preserve script evaluation history
  4953.         if ( attached ) {
  4954.             setGlobalEval( tmp );
  4955.         }
  4956.  
  4957.         // Capture executables
  4958.         if ( scripts ) {
  4959.             j = 0;
  4960.             while ( ( elem = tmp[ j++ ] ) ) {
  4961.                 if ( rscriptType.test( elem.type || "" ) ) {
  4962.                     scripts.push( elem );
  4963.                 }
  4964.             }
  4965.         }
  4966.     }
  4967.  
  4968.     return fragment;
  4969. }
  4970.  
  4971.  
  4972. ( function() {
  4973.     var fragment = document.createDocumentFragment(),
  4974.         div = fragment.appendChild( document.createElement( "div" ) ),
  4975.         input = document.createElement( "input" );
  4976.  
  4977.     // Support: Android 4.0 - 4.3 only
  4978.     // Check state lost if the name is set (#11217)
  4979.     // Support: Windows Web Apps (WWA)
  4980.     // `name` and `type` must use .setAttribute for WWA (#14901)
  4981.     input.setAttribute( "type", "radio" );
  4982.     input.setAttribute( "checked", "checked" );
  4983.     input.setAttribute( "name", "t" );
  4984.  
  4985.     div.appendChild( input );
  4986.  
  4987.     // Support: Android <=4.1 only
  4988.     // Older WebKit doesn't clone checked state correctly in fragments
  4989.     support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
  4990.  
  4991.     // Support: IE <=11 only
  4992.     // Make sure textarea (and checkbox) defaultValue is properly cloned
  4993.     div.innerHTML = "<textarea>x</textarea>";
  4994.     support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
  4995. } )();
  4996.  
  4997.  
  4998. var
  4999.     rkeyEvent = /^key/,
  5000.     rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
  5001.     rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
  5002.  
  5003. function returnTrue() {
  5004.     return true;
  5005. }
  5006.  
  5007. function returnFalse() {
  5008.     return false;
  5009. }
  5010.  
  5011. // Support: IE <=9 - 11+
  5012. // focus() and blur() are asynchronous, except when they are no-op.
  5013. // So expect focus to be synchronous when the element is already active,
  5014. // and blur to be synchronous when the element is not already active.
  5015. // (focus and blur are always synchronous in other supported browsers,
  5016. // this just defines when we can count on it).
  5017. function expectSync( elem, type ) {
  5018.     return ( elem === safeActiveElement() ) === ( type === "focus" );
  5019. }
  5020.  
  5021. // Support: IE <=9 only
  5022. // Accessing document.activeElement can throw unexpectedly
  5023. // https://bugs.jquery.com/ticket/13393
  5024. function safeActiveElement() {
  5025.     try {
  5026.         return document.activeElement;
  5027.     } catch ( err ) { }
  5028. }
  5029.  
  5030. function on( elem, types, selector, data, fn, one ) {
  5031.     var origFn, type;
  5032.  
  5033.     // Types can be a map of types/handlers
  5034.     if ( typeof types === "object" ) {
  5035.  
  5036.         // ( types-Object, selector, data )
  5037.         if ( typeof selector !== "string" ) {
  5038.  
  5039.             // ( types-Object, data )
  5040.             data = data || selector;
  5041.             selector = undefined;
  5042.         }
  5043.         for ( type in types ) {
  5044.             on( elem, type, selector, data, types[ type ], one );
  5045.         }
  5046.         return elem;
  5047.     }
  5048.  
  5049.     if ( data == null && fn == null ) {
  5050.  
  5051.         // ( types, fn )
  5052.         fn = selector;
  5053.         data = selector = undefined;
  5054.     } else if ( fn == null ) {
  5055.         if ( typeof selector === "string" ) {
  5056.  
  5057.             // ( types, selector, fn )
  5058.             fn = data;
  5059.             data = undefined;
  5060.         } else {
  5061.  
  5062.             // ( types, data, fn )
  5063.             fn = data;
  5064.             data = selector;
  5065.             selector = undefined;
  5066.         }
  5067.     }
  5068.     if ( fn === false ) {
  5069.         fn = returnFalse;
  5070.     } else if ( !fn ) {
  5071.         return elem;
  5072.     }
  5073.  
  5074.     if ( one === 1 ) {
  5075.         origFn = fn;
  5076.         fn = function( event ) {
  5077.  
  5078.             // Can use an empty set, since event contains the info
  5079.             jQuery().off( event );
  5080.             return origFn.apply( this, arguments );
  5081.         };
  5082.  
  5083.         // Use same guid so caller can remove using origFn
  5084.         fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
  5085.     }
  5086.     return elem.each( function() {
  5087.         jQuery.event.add( this, types, fn, data, selector );
  5088.     } );
  5089. }
  5090.  
  5091. /*
  5092.  * Helper functions for managing events -- not part of the public interface.
  5093.  * Props to Dean Edwards' addEvent library for many of the ideas.
  5094.  */
  5095. jQuery.event = {
  5096.  
  5097.     global: {},
  5098.  
  5099.     add: function( elem, types, handler, data, selector ) {
  5100.  
  5101.         var handleObjIn, eventHandle, tmp,
  5102.             events, t, handleObj,
  5103.             special, handlers, type, namespaces, origType,
  5104.             elemData = dataPriv.get( elem );
  5105.  
  5106.         // Don't attach events to noData or text/comment nodes (but allow plain objects)
  5107.         if ( !elemData ) {
  5108.             return;
  5109.         }
  5110.  
  5111.         // Caller can pass in an object of custom data in lieu of the handler
  5112.         if ( handler.handler ) {
  5113.             handleObjIn = handler;
  5114.             handler = handleObjIn.handler;
  5115.             selector = handleObjIn.selector;
  5116.         }
  5117.  
  5118.         // Ensure that invalid selectors throw exceptions at attach time
  5119.         // Evaluate against documentElement in case elem is a non-element node (e.g., document)
  5120.         if ( selector ) {
  5121.             jQuery.find.matchesSelector( documentElement, selector );
  5122.         }
  5123.  
  5124.         // Make sure that the handler has a unique ID, used to find/remove it later
  5125.         if ( !handler.guid ) {
  5126.             handler.guid = jQuery.guid++;
  5127.         }
  5128.  
  5129.         // Init the element's event structure and main handler, if this is the first
  5130.         if ( !( events = elemData.events ) ) {
  5131.             events = elemData.events = {};
  5132.         }
  5133.         if ( !( eventHandle = elemData.handle ) ) {
  5134.             eventHandle = elemData.handle = function( e ) {
  5135.  
  5136.                 // Discard the second event of a jQuery.event.trigger() and
  5137.                 // when an event is called after a page has unloaded
  5138.                 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
  5139.                     jQuery.event.dispatch.apply( elem, arguments ) : undefined;
  5140.             };
  5141.         }
  5142.  
  5143.         // Handle multiple events separated by a space
  5144.         types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
  5145.         t = types.length;
  5146.         while ( t-- ) {
  5147.             tmp = rtypenamespace.exec( types[ t ] ) || [];
  5148.             type = origType = tmp[ 1 ];
  5149.             namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
  5150.  
  5151.             // There *must* be a type, no attaching namespace-only handlers
  5152.             if ( !type ) {
  5153.                 continue;
  5154.             }
  5155.  
  5156.             // If event changes its type, use the special event handlers for the changed type
  5157.             special = jQuery.event.special[ type ] || {};
  5158.  
  5159.             // If selector defined, determine special event api type, otherwise given type
  5160.             type = ( selector ? special.delegateType : special.bindType ) || type;
  5161.  
  5162.             // Update special based on newly reset type
  5163.             special = jQuery.event.special[ type ] || {};
  5164.  
  5165.             // handleObj is passed to all event handlers
  5166.             handleObj = jQuery.extend( {
  5167.                 type: type,
  5168.                 origType: origType,
  5169.                 data: data,
  5170.                 handler: handler,
  5171.                 guid: handler.guid,
  5172.                 selector: selector,
  5173.                 needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
  5174.                 namespace: namespaces.join( "." )
  5175.             }, handleObjIn );
  5176.  
  5177.             // Init the event handler queue if we're the first
  5178.             if ( !( handlers = events[ type ] ) ) {
  5179.                 handlers = events[ type ] = [];
  5180.                 handlers.delegateCount = 0;
  5181.  
  5182.                 // Only use addEventListener if the special events handler returns false
  5183.                 if ( !special.setup ||
  5184.                     special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
  5185.  
  5186.                     if ( elem.addEventListener ) {
  5187.                         elem.addEventListener( type, eventHandle );
  5188.                     }
  5189.                 }
  5190.             }
  5191.  
  5192.             if ( special.add ) {
  5193.                 special.add.call( elem, handleObj );
  5194.  
  5195.                 if ( !handleObj.handler.guid ) {
  5196.                     handleObj.handler.guid = handler.guid;
  5197.                 }
  5198.             }
  5199.  
  5200.             // Add to the element's handler list, delegates in front
  5201.             if ( selector ) {
  5202.                 handlers.splice( handlers.delegateCount++, 0, handleObj );
  5203.             } else {
  5204.                 handlers.push( handleObj );
  5205.             }
  5206.  
  5207.             // Keep track of which events have ever been used, for event optimization
  5208.             jQuery.event.global[ type ] = true;
  5209.         }
  5210.  
  5211.     },
  5212.  
  5213.     // Detach an event or set of events from an element
  5214.     remove: function( elem, types, handler, selector, mappedTypes ) {
  5215.  
  5216.         var j, origCount, tmp,
  5217.             events, t, handleObj,
  5218.             special, handlers, type, namespaces, origType,
  5219.             elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
  5220.  
  5221.         if ( !elemData || !( events = elemData.events ) ) {
  5222.             return;
  5223.         }
  5224.  
  5225.         // Once for each type.namespace in types; type may be omitted
  5226.         types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
  5227.         t = types.length;
  5228.         while ( t-- ) {
  5229.             tmp = rtypenamespace.exec( types[ t ] ) || [];
  5230.             type = origType = tmp[ 1 ];
  5231.             namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
  5232.  
  5233.             // Unbind all events (on this namespace, if provided) for the element
  5234.             if ( !type ) {
  5235.                 for ( type in events ) {
  5236.                     jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
  5237.                 }
  5238.                 continue;
  5239.             }
  5240.  
  5241.             special = jQuery.event.special[ type ] || {};
  5242.             type = ( selector ? special.delegateType : special.bindType ) || type;
  5243.             handlers = events[ type ] || [];
  5244.             tmp = tmp[ 2 ] &&
  5245.                 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
  5246.  
  5247.             // Remove matching events
  5248.             origCount = j = handlers.length;
  5249.             while ( j-- ) {
  5250.                 handleObj = handlers[ j ];
  5251.  
  5252.                 if ( ( mappedTypes || origType === handleObj.origType ) &&
  5253.                     ( !handler || handler.guid === handleObj.guid ) &&
  5254.                     ( !tmp || tmp.test( handleObj.namespace ) ) &&
  5255.                     ( !selector || selector === handleObj.selector ||
  5256.                         selector === "**" && handleObj.selector ) ) {
  5257.                     handlers.splice( j, 1 );
  5258.  
  5259.                     if ( handleObj.selector ) {
  5260.                         handlers.delegateCount--;
  5261.                     }
  5262.                     if ( special.remove ) {
  5263.                         special.remove.call( elem, handleObj );
  5264.                     }
  5265.                 }
  5266.             }
  5267.  
  5268.             // Remove generic event handler if we removed something and no more handlers exist
  5269.             // (avoids potential for endless recursion during removal of special event handlers)
  5270.             if ( origCount && !handlers.length ) {
  5271.                 if ( !special.teardown ||
  5272.                     special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
  5273.  
  5274.                     jQuery.removeEvent( elem, type, elemData.handle );
  5275.                 }
  5276.  
  5277.                 delete events[ type ];
  5278.             }
  5279.         }
  5280.  
  5281.         // Remove data and the expando if it's no longer used
  5282.         if ( jQuery.isEmptyObject( events ) ) {
  5283.             dataPriv.remove( elem, "handle events" );
  5284.         }
  5285.     },
  5286.  
  5287.     dispatch: function( nativeEvent ) {
  5288.  
  5289.         // Make a writable jQuery.Event from the native event object
  5290.         var event = jQuery.event.fix( nativeEvent );
  5291.  
  5292.         var i, j, ret, matched, handleObj, handlerQueue,
  5293.             args = new Array( arguments.length ),
  5294.             handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
  5295.             special = jQuery.event.special[ event.type ] || {};
  5296.  
  5297.         // Use the fix-ed jQuery.Event rather than the (read-only) native event
  5298.         args[ 0 ] = event;
  5299.  
  5300.         for ( i = 1; i < arguments.length; i++ ) {
  5301.             args[ i ] = arguments[ i ];
  5302.         }
  5303.  
  5304.         event.delegateTarget = this;
  5305.  
  5306.         // Call the preDispatch hook for the mapped type, and let it bail if desired
  5307.         if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
  5308.             return;
  5309.         }
  5310.  
  5311.         // Determine handlers
  5312.         handlerQueue = jQuery.event.handlers.call( this, event, handlers );
  5313.  
  5314.         // Run delegates first; they may want to stop propagation beneath us
  5315.         i = 0;
  5316.         while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
  5317.             event.currentTarget = matched.elem;
  5318.  
  5319.             j = 0;
  5320.             while ( ( handleObj = matched.handlers[ j++ ] ) &&
  5321.                 !event.isImmediatePropagationStopped() ) {
  5322.  
  5323.                 // If the event is namespaced, then each handler is only invoked if it is
  5324.                 // specially universal or its namespaces are a superset of the event's.
  5325.                 if ( !event.rnamespace || handleObj.namespace === false ||
  5326.                     event.rnamespace.test( handleObj.namespace ) ) {
  5327.  
  5328.                     event.handleObj = handleObj;
  5329.                     event.data = handleObj.data;
  5330.  
  5331.                     ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
  5332.                         handleObj.handler ).apply( matched.elem, args );
  5333.  
  5334.                     if ( ret !== undefined ) {
  5335.                         if ( ( event.result = ret ) === false ) {
  5336.                             event.preventDefault();
  5337.                             event.stopPropagation();
  5338.                         }
  5339.                     }
  5340.                 }
  5341.             }
  5342.         }
  5343.  
  5344.         // Call the postDispatch hook for the mapped type
  5345.         if ( special.postDispatch ) {
  5346.             special.postDispatch.call( this, event );
  5347.         }
  5348.  
  5349.         return event.result;
  5350.     },
  5351.  
  5352.     handlers: function( event, handlers ) {
  5353.         var i, handleObj, sel, matchedHandlers, matchedSelectors,
  5354.             handlerQueue = [],
  5355.             delegateCount = handlers.delegateCount,
  5356.             cur = event.target;
  5357.  
  5358.         // Find delegate handlers
  5359.         if ( delegateCount &&
  5360.  
  5361.             // Support: IE <=9
  5362.             // Black-hole SVG <use> instance trees (trac-13180)
  5363.             cur.nodeType &&
  5364.  
  5365.             // Support: Firefox <=42
  5366.             // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
  5367.             // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
  5368.             // Support: IE 11 only
  5369.             // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
  5370.             !( event.type === "click" && event.button >= 1 ) ) {
  5371.  
  5372.             for ( ; cur !== this; cur = cur.parentNode || this ) {
  5373.  
  5374.                 // Don't check non-elements (#13208)
  5375.                 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
  5376.                 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
  5377.                     matchedHandlers = [];
  5378.                     matchedSelectors = {};
  5379.                     for ( i = 0; i < delegateCount; i++ ) {
  5380.                         handleObj = handlers[ i ];
  5381.  
  5382.                         // Don't conflict with Object.prototype properties (#13203)
  5383.                         sel = handleObj.selector + " ";
  5384.  
  5385.                         if ( matchedSelectors[ sel ] === undefined ) {
  5386.                             matchedSelectors[ sel ] = handleObj.needsContext ?
  5387.                                 jQuery( sel, this ).index( cur ) > -1 :
  5388.                                 jQuery.find( sel, this, null, [ cur ] ).length;
  5389.                         }
  5390.                         if ( matchedSelectors[ sel ] ) {
  5391.                             matchedHandlers.push( handleObj );
  5392.                         }
  5393.                     }
  5394.                     if ( matchedHandlers.length ) {
  5395.                         handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
  5396.                     }
  5397.                 }
  5398.             }
  5399.         }
  5400.  
  5401.         // Add the remaining (directly-bound) handlers
  5402.         cur = this;
  5403.         if ( delegateCount < handlers.length ) {
  5404.             handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
  5405.         }
  5406.  
  5407.         return handlerQueue;
  5408.     },
  5409.  
  5410.     addProp: function( name, hook ) {
  5411.         Object.defineProperty( jQuery.Event.prototype, name, {
  5412.             enumerable: true,
  5413.             configurable: true,
  5414.  
  5415.             get: isFunction( hook ) ?
  5416.                 function() {
  5417.                     if ( this.originalEvent ) {
  5418.                             return hook( this.originalEvent );
  5419.                     }
  5420.                 } :
  5421.                 function() {
  5422.                     if ( this.originalEvent ) {
  5423.                             return this.originalEvent[ name ];
  5424.                     }
  5425.                 },
  5426.  
  5427.             set: function( value ) {
  5428.                 Object.defineProperty( this, name, {
  5429.                     enumerable: true,
  5430.                     configurable: true,
  5431.                     writable: true,
  5432.                     value: value
  5433.                 } );
  5434.             }
  5435.         } );
  5436.     },
  5437.  
  5438.     fix: function( originalEvent ) {
  5439.         return originalEvent[ jQuery.expando ] ?
  5440.             originalEvent :
  5441.             new jQuery.Event( originalEvent );
  5442.     },
  5443.  
  5444.     special: {
  5445.         load: {
  5446.  
  5447.             // Prevent triggered image.load events from bubbling to window.load
  5448.             noBubble: true
  5449.         },
  5450.         click: {
  5451.  
  5452.             // Utilize native event to ensure correct state for checkable inputs
  5453.             setup: function( data ) {
  5454.  
  5455.                 // For mutual compressibility with _default, replace `this` access with a local var.
  5456.                 // `|| data` is dead code meant only to preserve the variable through minification.
  5457.                 var el = this || data;
  5458.  
  5459.                 // Claim the first handler
  5460.                 if ( rcheckableType.test( el.type ) &&
  5461.                     el.click && nodeName( el, "input" ) ) {
  5462.  
  5463.                     // dataPriv.set( el, "click", ... )
  5464.                     leverageNative( el, "click", returnTrue );
  5465.                 }
  5466.  
  5467.                 // Return false to allow normal processing in the caller
  5468.                 return false;
  5469.             },
  5470.             trigger: function( data ) {
  5471.  
  5472.                 // For mutual compressibility with _default, replace `this` access with a local var.
  5473.                 // `|| data` is dead code meant only to preserve the variable through minification.
  5474.                 var el = this || data;
  5475.  
  5476.                 // Force setup before triggering a click
  5477.                 if ( rcheckableType.test( el.type ) &&
  5478.                     el.click && nodeName( el, "input" ) ) {
  5479.  
  5480.                     leverageNative( el, "click" );
  5481.                 }
  5482.  
  5483.                 // Return non-false to allow normal event-path propagation
  5484.                 return true;
  5485.             },
  5486.  
  5487.             // For cross-browser consistency, suppress native .click() on links
  5488.             // Also prevent it if we're currently inside a leveraged native-event stack