NTP Analyzer  0.8.2
Analyze the operation of time servers
jquery.js
Go to the documentation of this file.
1 
15 (function( global, factory ) {
16 
17  if ( typeof module === "object" && typeof module.exports === "object" ) {
18  // For CommonJS and CommonJS-like environments where a proper `window`
19  // is present, execute the factory and get jQuery.
20  // For environments that do not have a `window` with a `document`
21  // (such as Node.js), expose a factory as module.exports.
22  // This accentuates the need for the creation of a real `window`.
23  // e.g. var jQuery = require("jquery")(window);
24  // See ticket #14549 for more info.
25  module.exports = global.document ?
26  factory( global, true ) :
27  function( w ) {
28  if ( !w.document ) {
29  throw new Error( "jQuery requires a window with a document" );
30  }
31  return factory( w );
32  };
33  } else {
34  factory( global );
35  }
36 
37 // Pass this if window is not defined yet
38 }(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
39 
40 // Support: Firefox 18+
41 // Can't be in strict mode, several libs including ASP.NET trace
42 // the stack via arguments.caller.callee and Firefox dies if
43 // you try to trace through "use strict" call chains. (#13335)
44 //"use strict";
45 var arr = [];
46 
47 var document = window.document;
48 
49 var slice = arr.slice;
50 
51 var concat = arr.concat;
52 
53 var push = arr.push;
54 
55 var indexOf = arr.indexOf;
56 
57 var class2type = {};
58 
59 var toString = class2type.toString;
60 
61 var hasOwn = class2type.hasOwnProperty;
62 
63 var support = {};
64 
65 
66 
67 var
68  version = "2.2.4",
69 
70  // Define a local copy of jQuery
71  jQuery = function( selector, context ) {
72 
73  // The jQuery object is actually just the init constructor 'enhanced'
74  // Need init if jQuery is called (just allow error to be thrown if not included)
75  return new jQuery.fn.init( selector, context );
76  },
77 
78  // Support: Android<4.1
79  // Make sure we trim BOM and NBSP
80  rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
81 
82  // Matches dashed string for camelizing
83  rmsPrefix = /^-ms-/,
84  rdashAlpha = /-([\da-z])/gi,
85 
86  // Used by jQuery.camelCase as callback to replace()
87  fcamelCase = function( all, letter ) {
88  return letter.toUpperCase();
89  };
90 
91 jQuery.fn = jQuery.prototype = {
92 
93  // The current version of jQuery being used
94  jquery: version,
95 
96  constructor: jQuery,
97 
98  // Start with an empty selector
99  selector: "",
100 
101  // The default length of a jQuery object is 0
102  length: 0,
103 
104  toArray: function() {
105  return slice.call( this );
106  },
107 
108  // Get the Nth element in the matched element set OR
109  // Get the whole matched element set as a clean array
110  get: function( num ) {
111  return num != null ?
112 
113  // Return just the one element from the set
114  ( num < 0 ? this[ num + this.length ] : this[ num ] ) :
115 
116  // Return all the elements in a clean array
117  slice.call( this );
118  },
119 
120  // Take an array of elements and push it onto the stack
121  // (returning the new matched element set)
122  pushStack: function( elems ) {
123 
124  // Build a new jQuery matched element set
125  var ret = jQuery.merge( this.constructor(), elems );
126 
127  // Add the old object onto the stack (as a reference)
128  ret.prevObject = this;
129  ret.context = this.context;
130 
131  // Return the newly-formed element set
132  return ret;
133  },
134 
135  // Execute a callback for every element in the matched set.
136  each: function( callback ) {
137  return jQuery.each( this, callback );
138  },
139 
140  map: function( callback ) {
141  return this.pushStack( jQuery.map( this, function( elem, i ) {
142  return callback.call( elem, i, elem );
143  } ) );
144  },
145 
146  slice: function() {
147  return this.pushStack( slice.apply( this, arguments ) );
148  },
149 
150  first: function() {
151  return this.eq( 0 );
152  },
153 
154  last: function() {
155  return this.eq( -1 );
156  },
157 
158  eq: function( i ) {
159  var len = this.length,
160  j = +i + ( i < 0 ? len : 0 );
161  return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
162  },
163 
164  end: function() {
165  return this.prevObject || this.constructor();
166  },
167 
168  // For internal use only.
169  // Behaves like an Array's method, not like a jQuery method.
170  push: push,
171  sort: arr.sort,
172  splice: arr.splice
173 };
174 
175 jQuery.extend = jQuery.fn.extend = function() {
176  var options, name, src, copy, copyIsArray, clone,
177  target = arguments[ 0 ] || {},
178  i = 1,
179  length = arguments.length,
180  deep = false;
181 
182  // Handle a deep copy situation
183  if ( typeof target === "boolean" ) {
184  deep = target;
185 
186  // Skip the boolean and the target
187  target = arguments[ i ] || {};
188  i++;
189  }
190 
191  // Handle case when target is a string or something (possible in deep copy)
192  if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
193  target = {};
194  }
195 
196  // Extend jQuery itself if only one argument is passed
197  if ( i === length ) {
198  target = this;
199  i--;
200  }
201 
202  for ( ; i < length; i++ ) {
203 
204  // Only deal with non-null/undefined values
205  if ( ( options = arguments[ i ] ) != null ) {
206 
207  // Extend the base object
208  for ( name in options ) {
209  src = target[ name ];
210  copy = options[ name ];
211 
212  // Prevent never-ending loop
213  if ( target === copy ) {
214  continue;
215  }
216 
217  // Recurse if we're merging plain objects or arrays
218  if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
219  ( copyIsArray = jQuery.isArray( copy ) ) ) ) {
220 
221  if ( copyIsArray ) {
222  copyIsArray = false;
223  clone = src && jQuery.isArray( src ) ? src : [];
224 
225  } else {
226  clone = src && jQuery.isPlainObject( src ) ? src : {};
227  }
228 
229  // Never move original objects, clone them
230  target[ name ] = jQuery.extend( deep, clone, copy );
231 
232  // Don't bring in undefined values
233  } else if ( copy !== undefined ) {
234  target[ name ] = copy;
235  }
236  }
237  }
238  }
239 
240  // Return the modified object
241  return target;
242 };
243 
244 jQuery.extend( {
245 
246  // Unique for each copy of jQuery on the page
247  expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
248 
249  // Assume jQuery is ready without the ready module
250  isReady: true,
251 
252  error: function( msg ) {
253  throw new Error( msg );
254  },
255 
256  noop: function() {},
257 
258  isFunction: function( obj ) {
259  return jQuery.type( obj ) === "function";
260  },
261 
262  isArray: Array.isArray,
263 
264  isWindow: function( obj ) {
265  return obj != null && obj === obj.window;
266  },
267 
268  isNumeric: function( obj ) {
269 
270  // parseFloat NaNs numeric-cast false positives (null|true|false|"")
271  // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
272  // subtraction forces infinities to NaN
273  // adding 1 corrects loss of precision from parseFloat (#15100)
274  var realStringObj = obj && obj.toString();
275  return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;
276  },
277 
278  isPlainObject: function( obj ) {
279  var key;
280 
281  // Not plain objects:
282  // - Any object or value whose internal [[Class]] property is not "[object Object]"
283  // - DOM nodes
284  // - window
285  if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
286  return false;
287  }
288 
289  // Not own constructor property must be Object
290  if ( obj.constructor &&
291  !hasOwn.call( obj, "constructor" ) &&
292  !hasOwn.call( obj.constructor.prototype || {}, "isPrototypeOf" ) ) {
293  return false;
294  }
295 
296  // Own properties are enumerated firstly, so to speed up,
297  // if last one is own, then all properties are own
298  for ( key in obj ) {}
299 
300  return key === undefined || hasOwn.call( obj, key );
301  },
302 
303  isEmptyObject: function( obj ) {
304  var name;
305  for ( name in obj ) {
306  return false;
307  }
308  return true;
309  },
310 
311  type: function( obj ) {
312  if ( obj == null ) {
313  return obj + "";
314  }
315 
316  // Support: Android<4.0, iOS<6 (functionish RegExp)
317  return typeof obj === "object" || typeof obj === "function" ?
318  class2type[ toString.call( obj ) ] || "object" :
319  typeof obj;
320  },
321 
322  // Evaluates a script in a global context
323  globalEval: function( code ) {
324  var script,
325  indirect = eval;
326 
327  code = jQuery.trim( code );
328 
329  if ( code ) {
330 
331  // If the code includes a valid, prologue position
332  // strict mode pragma, execute code by injecting a
333  // script tag into the document.
334  if ( code.indexOf( "use strict" ) === 1 ) {
335  script = document.createElement( "script" );
336  script.text = code;
337  document.head.appendChild( script ).parentNode.removeChild( script );
338  } else {
339 
340  // Otherwise, avoid the DOM node creation, insertion
341  // and removal by using an indirect global eval
342 
343  indirect( code );
344  }
345  }
346  },
347 
348  // Convert dashed to camelCase; used by the css and data modules
349  // Support: IE9-11+
350  // Microsoft forgot to hump their vendor prefix (#9572)
351  camelCase: function( string ) {
352  return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
353  },
354 
355  nodeName: function( elem, name ) {
356  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
357  },
358 
359  each: function( obj, callback ) {
360  var length, i = 0;
361 
362  if ( isArrayLike( obj ) ) {
363  length = obj.length;
364  for ( ; i < length; i++ ) {
365  if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
366  break;
367  }
368  }
369  } else {
370  for ( i in obj ) {
371  if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
372  break;
373  }
374  }
375  }
376 
377  return obj;
378  },
379 
380  // Support: Android<4.1
381  trim: function( text ) {
382  return text == null ?
383  "" :
384  ( text + "" ).replace( rtrim, "" );
385  },
386 
387  // results is for internal usage only
388  makeArray: function( arr, results ) {
389  var ret = results || [];
390 
391  if ( arr != null ) {
392  if ( isArrayLike( Object( arr ) ) ) {
393  jQuery.merge( ret,
394  typeof arr === "string" ?
395  [ arr ] : arr
396  );
397  } else {
398  push.call( ret, arr );
399  }
400  }
401 
402  return ret;
403  },
404 
405  inArray: function( elem, arr, i ) {
406  return arr == null ? -1 : indexOf.call( arr, elem, i );
407  },
408 
409  merge: function( first, second ) {
410  var len = +second.length,
411  j = 0,
412  i = first.length;
413 
414  for ( ; j < len; j++ ) {
415  first[ i++ ] = second[ j ];
416  }
417 
418  first.length = i;
419 
420  return first;
421  },
422 
423  grep: function( elems, callback, invert ) {
424  var callbackInverse,
425  matches = [],
426  i = 0,
427  length = elems.length,
428  callbackExpect = !invert;
429 
430  // Go through the array, only saving the items
431  // that pass the validator function
432  for ( ; i < length; i++ ) {
433  callbackInverse = !callback( elems[ i ], i );
434  if ( callbackInverse !== callbackExpect ) {
435  matches.push( elems[ i ] );
436  }
437  }
438 
439  return matches;
440  },
441 
442  // arg is for internal usage only
443  map: function( elems, callback, arg ) {
444  var length, value,
445  i = 0,
446  ret = [];
447 
448  // Go through the array, translating each of the items to their new values
449  if ( isArrayLike( elems ) ) {
450  length = elems.length;
451  for ( ; i < length; i++ ) {
452  value = callback( elems[ i ], i, arg );
453 
454  if ( value != null ) {
455  ret.push( value );
456  }
457  }
458 
459  // Go through every key on the object,
460  } else {
461  for ( i in elems ) {
462  value = callback( elems[ i ], i, arg );
463 
464  if ( value != null ) {
465  ret.push( value );
466  }
467  }
468  }
469 
470  // Flatten any nested arrays
471  return concat.apply( [], ret );
472  },
473 
474  // A global GUID counter for objects
475  guid: 1,
476 
477  // Bind a function to a context, optionally partially applying any
478  // arguments.
479  proxy: function( fn, context ) {
480  var tmp, args, proxy;
481 
482  if ( typeof context === "string" ) {
483  tmp = fn[ context ];
484  context = fn;
485  fn = tmp;
486  }
487 
488  // Quick check to determine if target is callable, in the spec
489  // this throws a TypeError, but we will just return undefined.
490  if ( !jQuery.isFunction( fn ) ) {
491  return undefined;
492  }
493 
494  // Simulated bind
495  args = slice.call( arguments, 2 );
496  proxy = function() {
497  return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
498  };
499 
500  // Set the guid of unique handler to the same of original handler, so it can be removed
501  proxy.guid = fn.guid = fn.guid || jQuery.guid++;
502 
503  return proxy;
504  },
505 
506  now: Date.now,
507 
508  // jQuery.support is not used in Core but other projects attach their
509  // properties to it so it needs to exist.
510  support: support
511 } );
512 
513 // JSHint would error on this code due to the Symbol not being defined in ES5.
514 // Defining this global in .jshintrc would create a danger of using the global
515 // unguarded in another place, it seems safer to just disable JSHint for these
516 // three lines.
517 /* jshint ignore: start */
518 if ( typeof Symbol === "function" ) {
519  jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
520 }
521 /* jshint ignore: end */
522 
523 // Populate the class2type map
524 jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
525 function( i, name ) {
526  class2type[ "[object " + name + "]" ] = name.toLowerCase();
527 } );
528 
529 function isArrayLike( obj ) {
530 
531  // Support: iOS 8.2 (not reproducible in simulator)
532  // `in` check used to prevent JIT error (gh-2145)
533  // hasOwn isn't used here due to false negatives
534  // regarding Nodelist length in IE
535  var length = !!obj && "length" in obj && obj.length,
536  type = jQuery.type( obj );
537 
538  if ( type === "function" || jQuery.isWindow( obj ) ) {
539  return false;
540  }
541 
542  return type === "array" || length === 0 ||
543  typeof length === "number" && length > 0 && ( length - 1 ) in obj;
544 }
545 var Sizzle =
556 (function( window ) {
557 
558 var i,
559  support,
560  Expr,
561  getText,
562  isXML,
563  tokenize,
564  compile,
565  select,
566  outermostContext,
567  sortInput,
568  hasDuplicate,
569 
570  // Local document vars
571  setDocument,
572  document,
573  docElem,
574  documentIsHTML,
575  rbuggyQSA,
576  rbuggyMatches,
577  matches,
578  contains,
579 
580  // Instance-specific data
581  expando = "sizzle" + 1 * new Date(),
582  preferredDoc = window.document,
583  dirruns = 0,
584  done = 0,
585  classCache = createCache(),
586  tokenCache = createCache(),
587  compilerCache = createCache(),
588  sortOrder = function( a, b ) {
589  if ( a === b ) {
590  hasDuplicate = true;
591  }
592  return 0;
593  },
594 
595  // General-purpose constants
596  MAX_NEGATIVE = 1 << 31,
597 
598  // Instance methods
599  hasOwn = ({}).hasOwnProperty,
600  arr = [],
601  pop = arr.pop,
602  push_native = arr.push,
603  push = arr.push,
604  slice = arr.slice,
605  // Use a stripped-down indexOf as it's faster than native
606  // http://jsperf.com/thor-indexof-vs-for/5
607  indexOf = function( list, elem ) {
608  var i = 0,
609  len = list.length;
610  for ( ; i < len; i++ ) {
611  if ( list[i] === elem ) {
612  return i;
613  }
614  }
615  return -1;
616  },
617 
618  booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
619 
620  // Regular expressions
621 
622  // http://www.w3.org/TR/css3-selectors/#whitespace
623  whitespace = "[\\x20\\t\\r\\n\\f]",
624 
625  // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
626  identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
627 
628  // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
629  attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
630  // Operator (capture 2)
631  "*([*^$|!~]?=)" + whitespace +
632  // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
633  "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
634  "*\\]",
635 
636  pseudos = ":(" + identifier + ")(?:\\((" +
637  // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
638  // 1. quoted (capture 3; capture 4 or capture 5)
639  "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
640  // 2. simple (capture 6)
641  "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
642  // 3. anything else (capture 2)
643  ".*" +
644  ")\\)|)",
645 
646  // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
647  rwhitespace = new RegExp( whitespace + "+", "g" ),
648  rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
649 
650  rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
651  rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
652 
653  rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
654 
655  rpseudo = new RegExp( pseudos ),
656  ridentifier = new RegExp( "^" + identifier + "$" ),
657 
658  matchExpr = {
659  "ID": new RegExp( "^#(" + identifier + ")" ),
660  "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
661  "TAG": new RegExp( "^(" + identifier + "|[*])" ),
662  "ATTR": new RegExp( "^" + attributes ),
663  "PSEUDO": new RegExp( "^" + pseudos ),
664  "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
665  "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
666  "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
667  "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
668  // For use in libraries implementing .is()
669  // We use this for POS matching in `select`
670  "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
671  whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
672  },
673 
674  rinputs = /^(?:input|select|textarea|button)$/i,
675  rheader = /^h\d$/i,
676 
677  rnative = /^[^{]+\{\s*\[native \w/,
678 
679  // Easily-parseable/retrievable ID or TAG or CLASS selectors
680  rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
681 
682  rsibling = /[+~]/,
683  rescape = /'|\\/g,
684 
685  // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
686  runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
687  funescape = function( _, escaped, escapedWhitespace ) {
688  var high = "0x" + escaped - 0x10000;
689  // NaN means non-codepoint
690  // Support: Firefox<24
691  // Workaround erroneous numeric interpretation of +"0x"
692  return high !== high || escapedWhitespace ?
693  escaped :
694  high < 0 ?
695  // BMP codepoint
696  String.fromCharCode( high + 0x10000 ) :
697  // Supplemental Plane codepoint (surrogate pair)
698  String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
699  },
700 
701  // Used for iframes
702  // See setDocument()
703  // Removing the function wrapper causes a "Permission Denied"
704  // error in IE
705  unloadHandler = function() {
706  setDocument();
707  };
708 
709 // Optimize for push.apply( _, NodeList )
710 try {
711  push.apply(
712  (arr = slice.call( preferredDoc.childNodes )),
713  preferredDoc.childNodes
714  );
715  // Support: Android<4.0
716  // Detect silently failing push.apply
717  arr[ preferredDoc.childNodes.length ].nodeType;
718 } catch ( e ) {
719  push = { apply: arr.length ?
720 
721  // Leverage slice if possible
722  function( target, els ) {
723  push_native.apply( target, slice.call(els) );
724  } :
725 
726  // Support: IE<9
727  // Otherwise append directly
728  function( target, els ) {
729  var j = target.length,
730  i = 0;
731  // Can't trust NodeList.length
732  while ( (target[j++] = els[i++]) ) {}
733  target.length = j - 1;
734  }
735  };
736 }
737 
738 function Sizzle( selector, context, results, seed ) {
739  var m, i, elem, nid, nidselect, match, groups, newSelector,
740  newContext = context && context.ownerDocument,
741 
742  // nodeType defaults to 9, since context defaults to document
743  nodeType = context ? context.nodeType : 9;
744 
745  results = results || [];
746 
747  // Return early from calls with invalid selector or context
748  if ( typeof selector !== "string" || !selector ||
749  nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
750 
751  return results;
752  }
753 
754  // Try to shortcut find operations (as opposed to filters) in HTML documents
755  if ( !seed ) {
756 
757  if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
758  setDocument( context );
759  }
760  context = context || document;
761 
762  if ( documentIsHTML ) {
763 
764  // If the selector is sufficiently simple, try using a "get*By*" DOM method
765  // (excepting DocumentFragment context, where the methods don't exist)
766  if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
767 
768  // ID selector
769  if ( (m = match[1]) ) {
770 
771  // Document context
772  if ( nodeType === 9 ) {
773  if ( (elem = context.getElementById( m )) ) {
774 
775  // Support: IE, Opera, Webkit
776  // TODO: identify versions
777  // getElementById can match elements by name instead of ID
778  if ( elem.id === m ) {
779  results.push( elem );
780  return results;
781  }
782  } else {
783  return results;
784  }
785 
786  // Element context
787  } else {
788 
789  // Support: IE, Opera, Webkit
790  // TODO: identify versions
791  // getElementById can match elements by name instead of ID
792  if ( newContext && (elem = newContext.getElementById( m )) &&
793  contains( context, elem ) &&
794  elem.id === m ) {
795 
796  results.push( elem );
797  return results;
798  }
799  }
800 
801  // Type selector
802  } else if ( match[2] ) {
803  push.apply( results, context.getElementsByTagName( selector ) );
804  return results;
805 
806  // Class selector
807  } else if ( (m = match[3]) && support.getElementsByClassName &&
808  context.getElementsByClassName ) {
809 
810  push.apply( results, context.getElementsByClassName( m ) );
811  return results;
812  }
813  }
814 
815  // Take advantage of querySelectorAll
816  if ( support.qsa &&
817  !compilerCache[ selector + " " ] &&
818  (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
819 
820  if ( nodeType !== 1 ) {
821  newContext = context;
822  newSelector = selector;
823 
824  // qSA looks outside Element context, which is not what we want
825  // Thanks to Andrew Dupont for this workaround technique
826  // Support: IE <=8
827  // Exclude object elements
828  } else if ( context.nodeName.toLowerCase() !== "object" ) {
829 
830  // Capture the context ID, setting it first if necessary
831  if ( (nid = context.getAttribute( "id" )) ) {
832  nid = nid.replace( rescape, "\\$&" );
833  } else {
834  context.setAttribute( "id", (nid = expando) );
835  }
836 
837  // Prefix every selector in the list
838  groups = tokenize( selector );
839  i = groups.length;
840  nidselect = ridentifier.test( nid ) ? "#" + nid : "[id='" + nid + "']";
841  while ( i-- ) {
842  groups[i] = nidselect + " " + toSelector( groups[i] );
843  }
844  newSelector = groups.join( "," );
845 
846  // Expand context for sibling selectors
847  newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
848  context;
849  }
850 
851  if ( newSelector ) {
852  try {
853  push.apply( results,
854  newContext.querySelectorAll( newSelector )
855  );
856  return results;
857  } catch ( qsaError ) {
858  } finally {
859  if ( nid === expando ) {
860  context.removeAttribute( "id" );
861  }
862  }
863  }
864  }
865  }
866  }
867 
868  // All others
869  return select( selector.replace( rtrim, "$1" ), context, results, seed );
870 }
871 
878 function createCache() {
879  var keys = [];
880 
881  function cache( key, value ) {
882  // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
883  if ( keys.push( key + " " ) > Expr.cacheLength ) {
884  // Only keep the most recent entries
885  delete cache[ keys.shift() ];
886  }
887  return (cache[ key + " " ] = value);
888  }
889  return cache;
890 }
891 
896 function markFunction( fn ) {
897  fn[ expando ] = true;
898  return fn;
899 }
900 
905 function assert( fn ) {
906  var div = document.createElement("div");
907 
908  try {
909  return !!fn( div );
910  } catch (e) {
911  return false;
912  } finally {
913  // Remove from its parent by default
914  if ( div.parentNode ) {
915  div.parentNode.removeChild( div );
916  }
917  // release memory in IE
918  div = null;
919  }
920 }
921 
927 function addHandle( attrs, handler ) {
928  var arr = attrs.split("|"),
929  i = arr.length;
930 
931  while ( i-- ) {
932  Expr.attrHandle[ arr[i] ] = handler;
933  }
934 }
935 
942 function siblingCheck( a, b ) {
943  var cur = b && a,
944  diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
945  ( ~b.sourceIndex || MAX_NEGATIVE ) -
946  ( ~a.sourceIndex || MAX_NEGATIVE );
947 
948  // Use IE sourceIndex if available on both nodes
949  if ( diff ) {
950  return diff;
951  }
952 
953  // Check if b follows a
954  if ( cur ) {
955  while ( (cur = cur.nextSibling) ) {
956  if ( cur === b ) {
957  return -1;
958  }
959  }
960  }
961 
962  return a ? 1 : -1;
963 }
964 
969 function createInputPseudo( type ) {
970  return function( elem ) {
971  var name = elem.nodeName.toLowerCase();
972  return name === "input" && elem.type === type;
973  };
974 }
975 
980 function createButtonPseudo( type ) {
981  return function( elem ) {
982  var name = elem.nodeName.toLowerCase();
983  return (name === "input" || name === "button") && elem.type === type;
984  };
985 }
986 
991 function createPositionalPseudo( fn ) {
992  return markFunction(function( argument ) {
993  argument = +argument;
994  return markFunction(function( seed, matches ) {
995  var j,
996  matchIndexes = fn( [], seed.length, argument ),
997  i = matchIndexes.length;
998 
999  // Match elements found at the specified indexes
1000  while ( i-- ) {
1001  if ( seed[ (j = matchIndexes[i]) ] ) {
1002  seed[j] = !(matches[j] = seed[j]);
1003  }
1004  }
1005  });
1006  });
1007 }
1008 
1014 function testContext( context ) {
1015  return context && typeof context.getElementsByTagName !== "undefined" && context;
1016 }
1017 
1018 // Expose support vars for convenience
1019 support = Sizzle.support = {};
1020 
1026 isXML = Sizzle.isXML = function( elem ) {
1027  // documentElement is verified for cases where it doesn't yet exist
1028  // (such as loading iframes in IE - #4833)
1029  var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1030  return documentElement ? documentElement.nodeName !== "HTML" : false;
1031 };
1032 
1038 setDocument = Sizzle.setDocument = function( node ) {
1039  var hasCompare, parent,
1040  doc = node ? node.ownerDocument || node : preferredDoc;
1041 
1042  // Return early if doc is invalid or already selected
1043  if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1044  return document;
1045  }
1046 
1047  // Update global variables
1048  document = doc;
1049  docElem = document.documentElement;
1050  documentIsHTML = !isXML( document );
1051 
1052  // Support: IE 9-11, Edge
1053  // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1054  if ( (parent = document.defaultView) && parent.top !== parent ) {
1055  // Support: IE 11
1056  if ( parent.addEventListener ) {
1057  parent.addEventListener( "unload", unloadHandler, false );
1058 
1059  // Support: IE 9 - 10 only
1060  } else if ( parent.attachEvent ) {
1061  parent.attachEvent( "onunload", unloadHandler );
1062  }
1063  }
1064 
1065  /* Attributes
1066  ---------------------------------------------------------------------- */
1067 
1068  // Support: IE<8
1069  // Verify that getAttribute really returns attributes and not properties
1070  // (excepting IE8 booleans)
1071  support.attributes = assert(function( div ) {
1072  div.className = "i";
1073  return !div.getAttribute("className");
1074  });
1075 
1076  /* getElement(s)By*
1077  ---------------------------------------------------------------------- */
1078 
1079  // Check if getElementsByTagName("*") returns only elements
1080  support.getElementsByTagName = assert(function( div ) {
1081  div.appendChild( document.createComment("") );
1082  return !div.getElementsByTagName("*").length;
1083  });
1084 
1085  // Support: IE<9
1086  support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1087 
1088  // Support: IE<10
1089  // Check if getElementById returns elements by name
1090  // The broken getElementById methods don't pick up programatically-set names,
1091  // so use a roundabout getElementsByName test
1092  support.getById = assert(function( div ) {
1093  docElem.appendChild( div ).id = expando;
1094  return !document.getElementsByName || !document.getElementsByName( expando ).length;
1095  });
1096 
1097  // ID find and filter
1098  if ( support.getById ) {
1099  Expr.find["ID"] = function( id, context ) {
1100  if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1101  var m = context.getElementById( id );
1102  return m ? [ m ] : [];
1103  }
1104  };
1105  Expr.filter["ID"] = function( id ) {
1106  var attrId = id.replace( runescape, funescape );
1107  return function( elem ) {
1108  return elem.getAttribute("id") === attrId;
1109  };
1110  };
1111  } else {
1112  // Support: IE6/7
1113  // getElementById is not reliable as a find shortcut
1114  delete Expr.find["ID"];
1115 
1116  Expr.filter["ID"] = function( id ) {
1117  var attrId = id.replace( runescape, funescape );
1118  return function( elem ) {
1119  var node = typeof elem.getAttributeNode !== "undefined" &&
1120  elem.getAttributeNode("id");
1121  return node && node.value === attrId;
1122  };
1123  };
1124  }
1125 
1126  // Tag
1127  Expr.find["TAG"] = support.getElementsByTagName ?
1128  function( tag, context ) {
1129  if ( typeof context.getElementsByTagName !== "undefined" ) {
1130  return context.getElementsByTagName( tag );
1131 
1132  // DocumentFragment nodes don't have gEBTN
1133  } else if ( support.qsa ) {
1134  return context.querySelectorAll( tag );
1135  }
1136  } :
1137 
1138  function( tag, context ) {
1139  var elem,
1140  tmp = [],
1141  i = 0,
1142  // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1143  results = context.getElementsByTagName( tag );
1144 
1145  // Filter out possible comments
1146  if ( tag === "*" ) {
1147  while ( (elem = results[i++]) ) {
1148  if ( elem.nodeType === 1 ) {
1149  tmp.push( elem );
1150  }
1151  }
1152 
1153  return tmp;
1154  }
1155  return results;
1156  };
1157 
1158  // Class
1159  Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1160  if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1161  return context.getElementsByClassName( className );
1162  }
1163  };
1164 
1165  /* QSA/matchesSelector
1166  ---------------------------------------------------------------------- */
1167 
1168  // QSA and matchesSelector support
1169 
1170  // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1171  rbuggyMatches = [];
1172 
1173  // qSa(:focus) reports false when true (Chrome 21)
1174  // We allow this because of a bug in IE8/9 that throws an error
1175  // whenever `document.activeElement` is accessed on an iframe
1176  // So, we allow :focus to pass through QSA all the time to avoid the IE error
1177  // See http://bugs.jquery.com/ticket/13378
1178  rbuggyQSA = [];
1179 
1180  if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1181  // Build QSA regex
1182  // Regex strategy adopted from Diego Perini
1183  assert(function( div ) {
1184  // Select is set to empty string on purpose
1185  // This is to test IE's treatment of not explicitly
1186  // setting a boolean content attribute,
1187  // since its presence should be enough
1188  // http://bugs.jquery.com/ticket/12359
1189  docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
1190  "<select id='" + expando + "-\r\\' msallowcapture=''>" +
1191  "<option selected=''></option></select>";
1192 
1193  // Support: IE8, Opera 11-12.16
1194  // Nothing should be selected when empty strings follow ^= or $= or *=
1195  // The test attribute must be unknown in Opera but "safe" for WinRT
1196  // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1197  if ( div.querySelectorAll("[msallowcapture^='']").length ) {
1198  rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1199  }
1200 
1201  // Support: IE8
1202  // Boolean attributes and "value" are not treated correctly
1203  if ( !div.querySelectorAll("[selected]").length ) {
1204  rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1205  }
1206 
1207  // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1208  if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1209  rbuggyQSA.push("~=");
1210  }
1211 
1212  // Webkit/Opera - :checked should return selected option elements
1213  // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1214  // IE8 throws error here and will not see later tests
1215  if ( !div.querySelectorAll(":checked").length ) {
1216  rbuggyQSA.push(":checked");
1217  }
1218 
1219  // Support: Safari 8+, iOS 8+
1220  // https://bugs.webkit.org/show_bug.cgi?id=136851
1221  // In-page `selector#id sibing-combinator selector` fails
1222  if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
1223  rbuggyQSA.push(".#.+[+~]");
1224  }
1225  });
1226 
1227  assert(function( div ) {
1228  // Support: Windows 8 Native Apps
1229  // The type and name attributes are restricted during .innerHTML assignment
1230  var input = document.createElement("input");
1231  input.setAttribute( "type", "hidden" );
1232  div.appendChild( input ).setAttribute( "name", "D" );
1233 
1234  // Support: IE8
1235  // Enforce case-sensitivity of name attribute
1236  if ( div.querySelectorAll("[name=d]").length ) {
1237  rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1238  }
1239 
1240  // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1241  // IE8 throws error here and will not see later tests
1242  if ( !div.querySelectorAll(":enabled").length ) {
1243  rbuggyQSA.push( ":enabled", ":disabled" );
1244  }
1245 
1246  // Opera 10-11 does not throw on post-comma invalid pseudos
1247  div.querySelectorAll("*,:x");
1248  rbuggyQSA.push(",.*:");
1249  });
1250  }
1251 
1252  if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1253  docElem.webkitMatchesSelector ||
1254  docElem.mozMatchesSelector ||
1255  docElem.oMatchesSelector ||
1256  docElem.msMatchesSelector) )) ) {
1257 
1258  assert(function( div ) {
1259  // Check to see if it's possible to do matchesSelector
1260  // on a disconnected node (IE 9)
1261  support.disconnectedMatch = matches.call( div, "div" );
1262 
1263  // This should fail with an exception
1264  // Gecko does not error, returns false instead
1265  matches.call( div, "[s!='']:x" );
1266  rbuggyMatches.push( "!=", pseudos );
1267  });
1268  }
1269 
1270  rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1271  rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1272 
1273  /* Contains
1274  ---------------------------------------------------------------------- */
1275  hasCompare = rnative.test( docElem.compareDocumentPosition );
1276 
1277  // Element contains another
1278  // Purposefully self-exclusive
1279  // As in, an element does not contain itself
1280  contains = hasCompare || rnative.test( docElem.contains ) ?
1281  function( a, b ) {
1282  var adown = a.nodeType === 9 ? a.documentElement : a,
1283  bup = b && b.parentNode;
1284  return a === bup || !!( bup && bup.nodeType === 1 && (
1285  adown.contains ?
1286  adown.contains( bup ) :
1287  a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1288  ));
1289  } :
1290  function( a, b ) {
1291  if ( b ) {
1292  while ( (b = b.parentNode) ) {
1293  if ( b === a ) {
1294  return true;
1295  }
1296  }
1297  }
1298  return false;
1299  };
1300 
1301  /* Sorting
1302  ---------------------------------------------------------------------- */
1303 
1304  // Document order sorting
1305  sortOrder = hasCompare ?
1306  function( a, b ) {
1307 
1308  // Flag for duplicate removal
1309  if ( a === b ) {
1310  hasDuplicate = true;
1311  return 0;
1312  }
1313 
1314  // Sort on method existence if only one input has compareDocumentPosition
1315  var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1316  if ( compare ) {
1317  return compare;
1318  }
1319 
1320  // Calculate position if both inputs belong to the same document
1321  compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1322  a.compareDocumentPosition( b ) :
1323 
1324  // Otherwise we know they are disconnected
1325  1;
1326 
1327  // Disconnected nodes
1328  if ( compare & 1 ||
1329  (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1330 
1331  // Choose the first element that is related to our preferred document
1332  if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1333  return -1;
1334  }
1335  if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1336  return 1;
1337  }
1338 
1339  // Maintain original order
1340  return sortInput ?
1341  ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1342  0;
1343  }
1344 
1345  return compare & 4 ? -1 : 1;
1346  } :
1347  function( a, b ) {
1348  // Exit early if the nodes are identical
1349  if ( a === b ) {
1350  hasDuplicate = true;
1351  return 0;
1352  }
1353 
1354  var cur,
1355  i = 0,
1356  aup = a.parentNode,
1357  bup = b.parentNode,
1358  ap = [ a ],
1359  bp = [ b ];
1360 
1361  // Parentless nodes are either documents or disconnected
1362  if ( !aup || !bup ) {
1363  return a === document ? -1 :
1364  b === document ? 1 :
1365  aup ? -1 :
1366  bup ? 1 :
1367  sortInput ?
1368  ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1369  0;
1370 
1371  // If the nodes are siblings, we can do a quick check
1372  } else if ( aup === bup ) {
1373  return siblingCheck( a, b );
1374  }
1375 
1376  // Otherwise we need full lists of their ancestors for comparison
1377  cur = a;
1378  while ( (cur = cur.parentNode) ) {
1379  ap.unshift( cur );
1380  }
1381  cur = b;
1382  while ( (cur = cur.parentNode) ) {
1383  bp.unshift( cur );
1384  }
1385 
1386  // Walk down the tree looking for a discrepancy
1387  while ( ap[i] === bp[i] ) {
1388  i++;
1389  }
1390 
1391  return i ?
1392  // Do a sibling check if the nodes have a common ancestor
1393  siblingCheck( ap[i], bp[i] ) :
1394 
1395  // Otherwise nodes in our document sort first
1396  ap[i] === preferredDoc ? -1 :
1397  bp[i] === preferredDoc ? 1 :
1398  0;
1399  };
1400 
1401  return document;
1402 };
1403 
1404 Sizzle.matches = function( expr, elements ) {
1405  return Sizzle( expr, null, null, elements );
1406 };
1407 
1408 Sizzle.matchesSelector = function( elem, expr ) {
1409  // Set document vars if needed
1410  if ( ( elem.ownerDocument || elem ) !== document ) {
1411  setDocument( elem );
1412  }
1413 
1414  // Make sure that attribute selectors are quoted
1415  expr = expr.replace( rattributeQuotes, "='$1']" );
1416 
1417  if ( support.matchesSelector && documentIsHTML &&
1418  !compilerCache[ expr + " " ] &&
1419  ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1420  ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
1421 
1422  try {
1423  var ret = matches.call( elem, expr );
1424 
1425  // IE 9's matchesSelector returns false on disconnected nodes
1426  if ( ret || support.disconnectedMatch ||
1427  // As well, disconnected nodes are said to be in a document
1428  // fragment in IE 9
1429  elem.document && elem.document.nodeType !== 11 ) {
1430  return ret;
1431  }
1432  } catch (e) {}
1433  }
1434 
1435  return Sizzle( expr, document, null, [ elem ] ).length > 0;
1436 };
1437 
1438 Sizzle.contains = function( context, elem ) {
1439  // Set document vars if needed
1440  if ( ( context.ownerDocument || context ) !== document ) {
1441  setDocument( context );
1442  }
1443  return contains( context, elem );
1444 };
1445 
1446 Sizzle.attr = function( elem, name ) {
1447  // Set document vars if needed
1448  if ( ( elem.ownerDocument || elem ) !== document ) {
1449  setDocument( elem );
1450  }
1451 
1452  var fn = Expr.attrHandle[ name.toLowerCase() ],
1453  // Don't get fooled by Object.prototype properties (jQuery #13807)
1454  val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1455  fn( elem, name, !documentIsHTML ) :
1456  undefined;
1457 
1458  return val !== undefined ?
1459  val :
1460  support.attributes || !documentIsHTML ?
1461  elem.getAttribute( name ) :
1462  (val = elem.getAttributeNode(name)) && val.specified ?
1463  val.value :
1464  null;
1465 };
1466 
1467 Sizzle.error = function( msg ) {
1468  throw new Error( "Syntax error, unrecognized expression: " + msg );
1469 };
1470 
1475 Sizzle.uniqueSort = function( results ) {
1476  var elem,
1477  duplicates = [],
1478  j = 0,
1479  i = 0;
1480 
1481  // Unless we *know* we can detect duplicates, assume their presence
1482  hasDuplicate = !support.detectDuplicates;
1483  sortInput = !support.sortStable && results.slice( 0 );
1484  results.sort( sortOrder );
1485 
1486  if ( hasDuplicate ) {
1487  while ( (elem = results[i++]) ) {
1488  if ( elem === results[ i ] ) {
1489  j = duplicates.push( i );
1490  }
1491  }
1492  while ( j-- ) {
1493  results.splice( duplicates[ j ], 1 );
1494  }
1495  }
1496 
1497  // Clear input after sorting to release objects
1498  // See https://github.com/jquery/sizzle/pull/225
1499  sortInput = null;
1500 
1501  return results;
1502 };
1503 
1508 getText = Sizzle.getText = function( elem ) {
1509  var node,
1510  ret = "",
1511  i = 0,
1512  nodeType = elem.nodeType;
1513 
1514  if ( !nodeType ) {
1515  // If no nodeType, this is expected to be an array
1516  while ( (node = elem[i++]) ) {
1517  // Do not traverse comment nodes
1518  ret += getText( node );
1519  }
1520  } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1521  // Use textContent for elements
1522  // innerText usage removed for consistency of new lines (jQuery #11153)
1523  if ( typeof elem.textContent === "string" ) {
1524  return elem.textContent;
1525  } else {
1526  // Traverse its children
1527  for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1528  ret += getText( elem );
1529  }
1530  }
1531  } else if ( nodeType === 3 || nodeType === 4 ) {
1532  return elem.nodeValue;
1533  }
1534  // Do not include comment or processing instruction nodes
1535 
1536  return ret;
1537 };
1538 
1539 Expr = Sizzle.selectors = {
1540 
1541  // Can be adjusted by the user
1542  cacheLength: 50,
1543 
1544  createPseudo: markFunction,
1545 
1546  match: matchExpr,
1547 
1548  attrHandle: {},
1549 
1550  find: {},
1551 
1552  relative: {
1553  ">": { dir: "parentNode", first: true },
1554  " ": { dir: "parentNode" },
1555  "+": { dir: "previousSibling", first: true },
1556  "~": { dir: "previousSibling" }
1557  },
1558 
1559  preFilter: {
1560  "ATTR": function( match ) {
1561  match[1] = match[1].replace( runescape, funescape );
1562 
1563  // Move the given value to match[3] whether quoted or unquoted
1564  match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1565 
1566  if ( match[2] === "~=" ) {
1567  match[3] = " " + match[3] + " ";
1568  }
1569 
1570  return match.slice( 0, 4 );
1571  },
1572 
1573  "CHILD": function( match ) {
1574  /* matches from matchExpr["CHILD"]
1575  1 type (only|nth|...)
1576  2 what (child|of-type)
1577  3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1578  4 xn-component of xn+y argument ([+-]?\d*n|)
1579  5 sign of xn-component
1580  6 x of xn-component
1581  7 sign of y-component
1582  8 y of y-component
1583  */
1584  match[1] = match[1].toLowerCase();
1585 
1586  if ( match[1].slice( 0, 3 ) === "nth" ) {
1587  // nth-* requires argument
1588  if ( !match[3] ) {
1589  Sizzle.error( match[0] );
1590  }
1591 
1592  // numeric x and y parameters for Expr.filter.CHILD
1593  // remember that false/true cast respectively to 0/1
1594  match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1595  match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1596 
1597  // other types prohibit arguments
1598  } else if ( match[3] ) {
1599  Sizzle.error( match[0] );
1600  }
1601 
1602  return match;
1603  },
1604 
1605  "PSEUDO": function( match ) {
1606  var excess,
1607  unquoted = !match[6] && match[2];
1608 
1609  if ( matchExpr["CHILD"].test( match[0] ) ) {
1610  return null;
1611  }
1612 
1613  // Accept quoted arguments as-is
1614  if ( match[3] ) {
1615  match[2] = match[4] || match[5] || "";
1616 
1617  // Strip excess characters from unquoted arguments
1618  } else if ( unquoted && rpseudo.test( unquoted ) &&
1619  // Get excess from tokenize (recursively)
1620  (excess = tokenize( unquoted, true )) &&
1621  // advance to the next closing parenthesis
1622  (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1623 
1624  // excess is a negative index
1625  match[0] = match[0].slice( 0, excess );
1626  match[2] = unquoted.slice( 0, excess );
1627  }
1628 
1629  // Return only captures needed by the pseudo filter method (type and argument)
1630  return match.slice( 0, 3 );
1631  }
1632  },
1633 
1634  filter: {
1635 
1636  "TAG": function( nodeNameSelector ) {
1637  var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1638  return nodeNameSelector === "*" ?
1639  function() { return true; } :
1640  function( elem ) {
1641  return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1642  };
1643  },
1644 
1645  "CLASS": function( className ) {
1646  var pattern = classCache[ className + " " ];
1647 
1648  return pattern ||
1649  (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1650  classCache( className, function( elem ) {
1651  return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1652  });
1653  },
1654 
1655  "ATTR": function( name, operator, check ) {
1656  return function( elem ) {
1657  var result = Sizzle.attr( elem, name );
1658 
1659  if ( result == null ) {
1660  return operator === "!=";
1661  }
1662  if ( !operator ) {
1663  return true;
1664  }
1665 
1666  result += "";
1667 
1668  return operator === "=" ? result === check :
1669  operator === "!=" ? result !== check :
1670  operator === "^=" ? check && result.indexOf( check ) === 0 :
1671  operator === "*=" ? check && result.indexOf( check ) > -1 :
1672  operator === "$=" ? check && result.slice( -check.length ) === check :
1673  operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1674  operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1675  false;
1676  };
1677  },
1678 
1679  "CHILD": function( type, what, argument, first, last ) {
1680  var simple = type.slice( 0, 3 ) !== "nth",
1681  forward = type.slice( -4 ) !== "last",
1682  ofType = what === "of-type";
1683 
1684  return first === 1 && last === 0 ?
1685 
1686  // Shortcut for :nth-*(n)
1687  function( elem ) {
1688  return !!elem.parentNode;
1689  } :
1690 
1691  function( elem, context, xml ) {
1692  var cache, uniqueCache, outerCache, node, nodeIndex, start,
1693  dir = simple !== forward ? "nextSibling" : "previousSibling",
1694  parent = elem.parentNode,
1695  name = ofType && elem.nodeName.toLowerCase(),
1696  useCache = !xml && !ofType,
1697  diff = false;
1698 
1699  if ( parent ) {
1700 
1701  // :(first|last|only)-(child|of-type)
1702  if ( simple ) {
1703  while ( dir ) {
1704  node = elem;
1705  while ( (node = node[ dir ]) ) {
1706  if ( ofType ?
1707  node.nodeName.toLowerCase() === name :
1708  node.nodeType === 1 ) {
1709 
1710  return false;
1711  }
1712  }
1713  // Reverse direction for :only-* (if we haven't yet done so)
1714  start = dir = type === "only" && !start && "nextSibling";
1715  }
1716  return true;
1717  }
1718 
1719  start = [ forward ? parent.firstChild : parent.lastChild ];
1720 
1721  // non-xml :nth-child(...) stores cache data on `parent`
1722  if ( forward && useCache ) {
1723 
1724  // Seek `elem` from a previously-cached index
1725 
1726  // ...in a gzip-friendly way
1727  node = parent;
1728  outerCache = node[ expando ] || (node[ expando ] = {});
1729 
1730  // Support: IE <9 only
1731  // Defend against cloned attroperties (jQuery gh-1709)
1732  uniqueCache = outerCache[ node.uniqueID ] ||
1733  (outerCache[ node.uniqueID ] = {});
1734 
1735  cache = uniqueCache[ type ] || [];
1736  nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1737  diff = nodeIndex && cache[ 2 ];
1738  node = nodeIndex && parent.childNodes[ nodeIndex ];
1739 
1740  while ( (node = ++nodeIndex && node && node[ dir ] ||
1741 
1742  // Fallback to seeking `elem` from the start
1743  (diff = nodeIndex = 0) || start.pop()) ) {
1744 
1745  // When found, cache indexes on `parent` and break
1746  if ( node.nodeType === 1 && ++diff && node === elem ) {
1747  uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1748  break;
1749  }
1750  }
1751 
1752  } else {
1753  // Use previously-cached element index if available
1754  if ( useCache ) {
1755  // ...in a gzip-friendly way
1756  node = elem;
1757  outerCache = node[ expando ] || (node[ expando ] = {});
1758 
1759  // Support: IE <9 only
1760  // Defend against cloned attroperties (jQuery gh-1709)
1761  uniqueCache = outerCache[ node.uniqueID ] ||
1762  (outerCache[ node.uniqueID ] = {});
1763 
1764  cache = uniqueCache[ type ] || [];
1765  nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1766  diff = nodeIndex;
1767  }
1768 
1769  // xml :nth-child(...)
1770  // or :nth-last-child(...) or :nth(-last)?-of-type(...)
1771  if ( diff === false ) {
1772  // Use the same loop as above to seek `elem` from the start
1773  while ( (node = ++nodeIndex && node && node[ dir ] ||
1774  (diff = nodeIndex = 0) || start.pop()) ) {
1775 
1776  if ( ( ofType ?
1777  node.nodeName.toLowerCase() === name :
1778  node.nodeType === 1 ) &&
1779  ++diff ) {
1780 
1781  // Cache the index of each encountered element
1782  if ( useCache ) {
1783  outerCache = node[ expando ] || (node[ expando ] = {});
1784 
1785  // Support: IE <9 only
1786  // Defend against cloned attroperties (jQuery gh-1709)
1787  uniqueCache = outerCache[ node.uniqueID ] ||
1788  (outerCache[ node.uniqueID ] = {});
1789 
1790  uniqueCache[ type ] = [ dirruns, diff ];
1791  }
1792 
1793  if ( node === elem ) {
1794  break;
1795  }
1796  }
1797  }
1798  }
1799  }
1800 
1801  // Incorporate the offset, then check against cycle size
1802  diff -= last;
1803  return diff === first || ( diff % first === 0 && diff / first >= 0 );
1804  }
1805  };
1806  },
1807 
1808  "PSEUDO": function( pseudo, argument ) {
1809  // pseudo-class names are case-insensitive
1810  // http://www.w3.org/TR/selectors/#pseudo-classes
1811  // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1812  // Remember that setFilters inherits from pseudos
1813  var args,
1814  fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1815  Sizzle.error( "unsupported pseudo: " + pseudo );
1816 
1817  // The user may use createPseudo to indicate that
1818  // arguments are needed to create the filter function
1819  // just as Sizzle does
1820  if ( fn[ expando ] ) {
1821  return fn( argument );
1822  }
1823 
1824  // But maintain support for old signatures
1825  if ( fn.length > 1 ) {
1826  args = [ pseudo, pseudo, "", argument ];
1827  return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1828  markFunction(function( seed, matches ) {
1829  var idx,
1830  matched = fn( seed, argument ),
1831  i = matched.length;
1832  while ( i-- ) {
1833  idx = indexOf( seed, matched[i] );
1834  seed[ idx ] = !( matches[ idx ] = matched[i] );
1835  }
1836  }) :
1837  function( elem ) {
1838  return fn( elem, 0, args );
1839  };
1840  }
1841 
1842  return fn;
1843  }
1844  },
1845 
1846  pseudos: {
1847  // Potentially complex pseudos
1848  "not": markFunction(function( selector ) {
1849  // Trim the selector passed to compile
1850  // to avoid treating leading and trailing
1851  // spaces as combinators
1852  var input = [],
1853  results = [],
1854  matcher = compile( selector.replace( rtrim, "$1" ) );
1855 
1856  return matcher[ expando ] ?
1857  markFunction(function( seed, matches, context, xml ) {
1858  var elem,
1859  unmatched = matcher( seed, null, xml, [] ),
1860  i = seed.length;
1861 
1862  // Match elements unmatched by `matcher`
1863  while ( i-- ) {
1864  if ( (elem = unmatched[i]) ) {
1865  seed[i] = !(matches[i] = elem);
1866  }
1867  }
1868  }) :
1869  function( elem, context, xml ) {
1870  input[0] = elem;
1871  matcher( input, null, xml, results );
1872  // Don't keep the element (issue #299)
1873  input[0] = null;
1874  return !results.pop();
1875  };
1876  }),
1877 
1878  "has": markFunction(function( selector ) {
1879  return function( elem ) {
1880  return Sizzle( selector, elem ).length > 0;
1881  };
1882  }),
1883 
1884  "contains": markFunction(function( text ) {
1885  text = text.replace( runescape, funescape );
1886  return function( elem ) {
1887  return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1888  };
1889  }),
1890 
1891  // "Whether an element is represented by a :lang() selector
1892  // is based solely on the element's language value
1893  // being equal to the identifier C,
1894  // or beginning with the identifier C immediately followed by "-".
1895  // The matching of C against the element's language value is performed case-insensitively.
1896  // The identifier C does not have to be a valid language name."
1897  // http://www.w3.org/TR/selectors/#lang-pseudo
1898  "lang": markFunction( function( lang ) {
1899  // lang value must be a valid identifier
1900  if ( !ridentifier.test(lang || "") ) {
1901  Sizzle.error( "unsupported lang: " + lang );
1902  }
1903  lang = lang.replace( runescape, funescape ).toLowerCase();
1904  return function( elem ) {
1905  var elemLang;
1906  do {
1907  if ( (elemLang = documentIsHTML ?
1908  elem.lang :
1909  elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
1910 
1911  elemLang = elemLang.toLowerCase();
1912  return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1913  }
1914  } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
1915  return false;
1916  };
1917  }),
1918 
1919  // Miscellaneous
1920  "target": function( elem ) {
1921  var hash = window.location && window.location.hash;
1922  return hash && hash.slice( 1 ) === elem.id;
1923  },
1924 
1925  "root": function( elem ) {
1926  return elem === docElem;
1927  },
1928 
1929  "focus": function( elem ) {
1930  return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1931  },
1932 
1933  // Boolean properties
1934  "enabled": function( elem ) {
1935  return elem.disabled === false;
1936  },
1937 
1938  "disabled": function( elem ) {
1939  return elem.disabled === true;
1940  },
1941 
1942  "checked": function( elem ) {
1943  // In CSS3, :checked should return both checked and selected elements
1944  // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1945  var nodeName = elem.nodeName.toLowerCase();
1946  return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1947  },
1948 
1949  "selected": function( elem ) {
1950  // Accessing this property makes selected-by-default
1951  // options in Safari work properly
1952  if ( elem.parentNode ) {
1953  elem.parentNode.selectedIndex;
1954  }
1955 
1956  return elem.selected === true;
1957  },
1958 
1959  // Contents
1960  "empty": function( elem ) {
1961  // http://www.w3.org/TR/selectors/#empty-pseudo
1962  // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1963  // but not by others (comment: 8; processing instruction: 7; etc.)
1964  // nodeType < 6 works because attributes (2) do not appear as children
1965  for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1966  if ( elem.nodeType < 6 ) {
1967  return false;
1968  }
1969  }
1970  return true;
1971  },
1972 
1973  "parent": function( elem ) {
1974  return !Expr.pseudos["empty"]( elem );
1975  },
1976 
1977  // Element/input types
1978  "header": function( elem ) {
1979  return rheader.test( elem.nodeName );
1980  },
1981 
1982  "input": function( elem ) {
1983  return rinputs.test( elem.nodeName );
1984  },
1985 
1986  "button": function( elem ) {
1987  var name = elem.nodeName.toLowerCase();
1988  return name === "input" && elem.type === "button" || name === "button";
1989  },
1990 
1991  "text": function( elem ) {
1992  var attr;
1993  return elem.nodeName.toLowerCase() === "input" &&
1994  elem.type === "text" &&
1995 
1996  // Support: IE<8
1997  // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
1998  ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
1999  },
2000 
2001  // Position-in-collection
2002  "first": createPositionalPseudo(function() {
2003  return [ 0 ];
2004  }),
2005 
2006  "last": createPositionalPseudo(function( matchIndexes, length ) {
2007  return [ length - 1 ];
2008  }),
2009 
2010  "eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2011  return [ argument < 0 ? argument + length : argument ];
2012  }),
2013 
2014  "even": createPositionalPseudo(function( matchIndexes, length ) {
2015  var i = 0;
2016  for ( ; i < length; i += 2 ) {
2017  matchIndexes.push( i );
2018  }
2019  return matchIndexes;
2020  }),
2021 
2022  "odd": createPositionalPseudo(function( matchIndexes, length ) {
2023  var i = 1;
2024  for ( ; i < length; i += 2 ) {
2025  matchIndexes.push( i );
2026  }
2027  return matchIndexes;
2028  }),
2029 
2030  "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2031  var i = argument < 0 ? argument + length : argument;
2032  for ( ; --i >= 0; ) {
2033  matchIndexes.push( i );
2034  }
2035  return matchIndexes;
2036  }),
2037 
2038  "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2039  var i = argument < 0 ? argument + length : argument;
2040  for ( ; ++i < length; ) {
2041  matchIndexes.push( i );
2042  }
2043  return matchIndexes;
2044  })
2045  }
2046 };
2047 
2048 Expr.pseudos["nth"] = Expr.pseudos["eq"];
2049 
2050 // Add button/input type pseudos
2051 for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2052  Expr.pseudos[ i ] = createInputPseudo( i );
2053 }
2054 for ( i in { submit: true, reset: true } ) {
2055  Expr.pseudos[ i ] = createButtonPseudo( i );
2056 }
2057 
2058 // Easy API for creating new setFilters
2059 function setFilters() {}
2060 setFilters.prototype = Expr.filters = Expr.pseudos;
2061 Expr.setFilters = new setFilters();
2062 
2063 tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2064  var matched, match, tokens, type,
2065  soFar, groups, preFilters,
2066  cached = tokenCache[ selector + " " ];
2067 
2068  if ( cached ) {
2069  return parseOnly ? 0 : cached.slice( 0 );
2070  }
2071 
2072  soFar = selector;
2073  groups = [];
2074  preFilters = Expr.preFilter;
2075 
2076  while ( soFar ) {
2077 
2078  // Comma and first run
2079  if ( !matched || (match = rcomma.exec( soFar )) ) {
2080  if ( match ) {
2081  // Don't consume trailing commas as valid
2082  soFar = soFar.slice( match[0].length ) || soFar;
2083  }
2084  groups.push( (tokens = []) );
2085  }
2086 
2087  matched = false;
2088 
2089  // Combinators
2090  if ( (match = rcombinators.exec( soFar )) ) {
2091  matched = match.shift();
2092  tokens.push({
2093  value: matched,
2094  // Cast descendant combinators to space
2095  type: match[0].replace( rtrim, " " )
2096  });
2097  soFar = soFar.slice( matched.length );
2098  }
2099 
2100  // Filters
2101  for ( type in Expr.filter ) {
2102  if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2103  (match = preFilters[ type ]( match ))) ) {
2104  matched = match.shift();
2105  tokens.push({
2106  value: matched,
2107  type: type,
2108  matches: match
2109  });
2110  soFar = soFar.slice( matched.length );
2111  }
2112  }
2113 
2114  if ( !matched ) {
2115  break;
2116  }
2117  }
2118 
2119  // Return the length of the invalid excess
2120  // if we're just parsing
2121  // Otherwise, throw an error or return tokens
2122  return parseOnly ?
2123  soFar.length :
2124  soFar ?
2125  Sizzle.error( selector ) :
2126  // Cache the tokens
2127  tokenCache( selector, groups ).slice( 0 );
2128 };
2129 
2130 function toSelector( tokens ) {
2131  var i = 0,
2132  len = tokens.length,
2133  selector = "";
2134  for ( ; i < len; i++ ) {
2135  selector += tokens[i].value;
2136  }
2137  return selector;
2138 }
2139 
2140 function addCombinator( matcher, combinator, base ) {
2141  var dir = combinator.dir,
2142  checkNonElements = base && dir === "parentNode",
2143  doneName = done++;
2144 
2145  return combinator.first ?
2146  // Check against closest ancestor/preceding element
2147  function( elem, context, xml ) {
2148  while ( (elem = elem[ dir ]) ) {
2149  if ( elem.nodeType === 1 || checkNonElements ) {
2150  return matcher( elem, context, xml );
2151  }
2152  }
2153  } :
2154 
2155  // Check against all ancestor/preceding elements
2156  function( elem, context, xml ) {
2157  var oldCache, uniqueCache, outerCache,
2158  newCache = [ dirruns, doneName ];
2159 
2160  // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2161  if ( xml ) {
2162  while ( (elem = elem[ dir ]) ) {
2163  if ( elem.nodeType === 1 || checkNonElements ) {
2164  if ( matcher( elem, context, xml ) ) {
2165  return true;
2166  }
2167  }
2168  }
2169  } else {
2170  while ( (elem = elem[ dir ]) ) {
2171  if ( elem.nodeType === 1 || checkNonElements ) {
2172  outerCache = elem[ expando ] || (elem[ expando ] = {});
2173 
2174  // Support: IE <9 only
2175  // Defend against cloned attroperties (jQuery gh-1709)
2176  uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2177 
2178  if ( (oldCache = uniqueCache[ dir ]) &&
2179  oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2180 
2181  // Assign to newCache so results back-propagate to previous elements
2182  return (newCache[ 2 ] = oldCache[ 2 ]);
2183  } else {
2184  // Reuse newcache so results back-propagate to previous elements
2185  uniqueCache[ dir ] = newCache;
2186 
2187  // A match means we're done; a fail means we have to keep checking
2188  if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2189  return true;
2190  }
2191  }
2192  }
2193  }
2194  }
2195  };
2196 }
2197 
2198 function elementMatcher( matchers ) {
2199  return matchers.length > 1 ?
2200  function( elem, context, xml ) {
2201  var i = matchers.length;
2202  while ( i-- ) {
2203  if ( !matchers[i]( elem, context, xml ) ) {
2204  return false;
2205  }
2206  }
2207  return true;
2208  } :
2209  matchers[0];
2210 }
2211 
2212 function multipleContexts( selector, contexts, results ) {
2213  var i = 0,
2214  len = contexts.length;
2215  for ( ; i < len; i++ ) {
2216  Sizzle( selector, contexts[i], results );
2217  }
2218  return results;
2219 }
2220 
2221 function condense( unmatched, map, filter, context, xml ) {
2222  var elem,
2223  newUnmatched = [],
2224  i = 0,
2225  len = unmatched.length,
2226  mapped = map != null;
2227 
2228  for ( ; i < len; i++ ) {
2229  if ( (elem = unmatched[i]) ) {
2230  if ( !filter || filter( elem, context, xml ) ) {
2231  newUnmatched.push( elem );
2232  if ( mapped ) {
2233  map.push( i );
2234  }
2235  }
2236  }
2237  }
2238 
2239  return newUnmatched;
2240 }
2241 
2242 function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2243  if ( postFilter && !postFilter[ expando ] ) {
2244  postFilter = setMatcher( postFilter );
2245  }
2246  if ( postFinder && !postFinder[ expando ] ) {
2247  postFinder = setMatcher( postFinder, postSelector );
2248  }
2249  return markFunction(function( seed, results, context, xml ) {
2250  var temp, i, elem,
2251  preMap = [],
2252  postMap = [],
2253  preexisting = results.length,
2254 
2255  // Get initial elements from seed or context
2256  elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2257 
2258  // Prefilter to get matcher input, preserving a map for seed-results synchronization
2259  matcherIn = preFilter && ( seed || !selector ) ?
2260  condense( elems, preMap, preFilter, context, xml ) :
2261  elems,
2262 
2263  matcherOut = matcher ?
2264  // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2265  postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2266 
2267  // ...intermediate processing is necessary
2268  [] :
2269 
2270  // ...otherwise use results directly
2271  results :
2272  matcherIn;
2273 
2274  // Find primary matches
2275  if ( matcher ) {
2276  matcher( matcherIn, matcherOut, context, xml );
2277  }
2278 
2279  // Apply postFilter
2280  if ( postFilter ) {
2281  temp = condense( matcherOut, postMap );
2282  postFilter( temp, [], context, xml );
2283 
2284  // Un-match failing elements by moving them back to matcherIn
2285  i = temp.length;
2286  while ( i-- ) {
2287  if ( (elem = temp[i]) ) {
2288  matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2289  }
2290  }
2291  }
2292 
2293  if ( seed ) {
2294  if ( postFinder || preFilter ) {
2295  if ( postFinder ) {
2296  // Get the final matcherOut by condensing this intermediate into postFinder contexts
2297  temp = [];
2298  i = matcherOut.length;
2299  while ( i-- ) {
2300  if ( (elem = matcherOut[i]) ) {
2301  // Restore matcherIn since elem is not yet a final match
2302  temp.push( (matcherIn[i] = elem) );
2303  }
2304  }
2305  postFinder( null, (matcherOut = []), temp, xml );
2306  }
2307 
2308  // Move matched elements from seed to results to keep them synchronized
2309  i = matcherOut.length;
2310  while ( i-- ) {
2311  if ( (elem = matcherOut[i]) &&
2312  (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2313 
2314  seed[temp] = !(results[temp] = elem);
2315  }
2316  }
2317  }
2318 
2319  // Add elements to results, through postFinder if defined
2320  } else {
2321  matcherOut = condense(
2322  matcherOut === results ?
2323  matcherOut.splice( preexisting, matcherOut.length ) :
2324  matcherOut
2325  );
2326  if ( postFinder ) {
2327  postFinder( null, results, matcherOut, xml );
2328  } else {
2329  push.apply( results, matcherOut );
2330  }
2331  }
2332  });
2333 }
2334 
2335 function matcherFromTokens( tokens ) {
2336  var checkContext, matcher, j,
2337  len = tokens.length,
2338  leadingRelative = Expr.relative[ tokens[0].type ],
2339  implicitRelative = leadingRelative || Expr.relative[" "],
2340  i = leadingRelative ? 1 : 0,
2341 
2342  // The foundational matcher ensures that elements are reachable from top-level context(s)
2343  matchContext = addCombinator( function( elem ) {
2344  return elem === checkContext;
2345  }, implicitRelative, true ),
2346  matchAnyContext = addCombinator( function( elem ) {
2347  return indexOf( checkContext, elem ) > -1;
2348  }, implicitRelative, true ),
2349  matchers = [ function( elem, context, xml ) {
2350  var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2351  (checkContext = context).nodeType ?
2352  matchContext( elem, context, xml ) :
2353  matchAnyContext( elem, context, xml ) );
2354  // Avoid hanging onto element (issue #299)
2355  checkContext = null;
2356  return ret;
2357  } ];
2358 
2359  for ( ; i < len; i++ ) {
2360  if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2361  matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2362  } else {
2363  matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2364 
2365  // Return special upon seeing a positional matcher
2366  if ( matcher[ expando ] ) {
2367  // Find the next relative operator (if any) for proper handling
2368  j = ++i;
2369  for ( ; j < len; j++ ) {
2370  if ( Expr.relative[ tokens[j].type ] ) {
2371  break;
2372  }
2373  }
2374  return setMatcher(
2375  i > 1 && elementMatcher( matchers ),
2376  i > 1 && toSelector(
2377  // If the preceding token was a descendant combinator, insert an implicit any-element `*`
2378  tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2379  ).replace( rtrim, "$1" ),
2380  matcher,
2381  i < j && matcherFromTokens( tokens.slice( i, j ) ),
2382  j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2383  j < len && toSelector( tokens )
2384  );
2385  }
2386  matchers.push( matcher );
2387  }
2388  }
2389 
2390  return elementMatcher( matchers );
2391 }
2392 
2393 function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2394  var bySet = setMatchers.length > 0,
2395  byElement = elementMatchers.length > 0,
2396  superMatcher = function( seed, context, xml, results, outermost ) {
2397  var elem, j, matcher,
2398  matchedCount = 0,
2399  i = "0",
2400  unmatched = seed && [],
2401  setMatched = [],
2402  contextBackup = outermostContext,
2403  // We must always have either seed elements or outermost context
2404  elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2405  // Use integer dirruns iff this is the outermost matcher
2406  dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2407  len = elems.length;
2408 
2409  if ( outermost ) {
2410  outermostContext = context === document || context || outermost;
2411  }
2412 
2413  // Add elements passing elementMatchers directly to results
2414  // Support: IE<9, Safari
2415  // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2416  for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2417  if ( byElement && elem ) {
2418  j = 0;
2419  if ( !context && elem.ownerDocument !== document ) {
2420  setDocument( elem );
2421  xml = !documentIsHTML;
2422  }
2423  while ( (matcher = elementMatchers[j++]) ) {
2424  if ( matcher( elem, context || document, xml) ) {
2425  results.push( elem );
2426  break;
2427  }
2428  }
2429  if ( outermost ) {
2430  dirruns = dirrunsUnique;
2431  }
2432  }
2433 
2434  // Track unmatched elements for set filters
2435  if ( bySet ) {
2436  // They will have gone through all possible matchers
2437  if ( (elem = !matcher && elem) ) {
2438  matchedCount--;
2439  }
2440 
2441  // Lengthen the array for every element, matched or not
2442  if ( seed ) {
2443  unmatched.push( elem );
2444  }
2445  }
2446  }
2447 
2448  // `i` is now the count of elements visited above, and adding it to `matchedCount`
2449  // makes the latter nonnegative.
2450  matchedCount += i;
2451 
2452  // Apply set filters to unmatched elements
2453  // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2454  // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2455  // no element matchers and no seed.
2456  // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2457  // case, which will result in a "00" `matchedCount` that differs from `i` but is also
2458  // numerically zero.
2459  if ( bySet && i !== matchedCount ) {
2460  j = 0;
2461  while ( (matcher = setMatchers[j++]) ) {
2462  matcher( unmatched, setMatched, context, xml );
2463  }
2464 
2465  if ( seed ) {
2466  // Reintegrate element matches to eliminate the need for sorting
2467  if ( matchedCount > 0 ) {
2468  while ( i-- ) {
2469  if ( !(unmatched[i] || setMatched[i]) ) {
2470  setMatched[i] = pop.call( results );
2471  }
2472  }
2473  }
2474 
2475  // Discard index placeholder values to get only actual matches
2476  setMatched = condense( setMatched );
2477  }
2478 
2479  // Add matches to results
2480  push.apply( results, setMatched );
2481 
2482  // Seedless set matches succeeding multiple successful matchers stipulate sorting
2483  if ( outermost && !seed && setMatched.length > 0 &&
2484  ( matchedCount + setMatchers.length ) > 1 ) {
2485 
2486  Sizzle.uniqueSort( results );
2487  }
2488  }
2489 
2490  // Override manipulation of globals by nested matchers
2491  if ( outermost ) {
2492  dirruns = dirrunsUnique;
2493  outermostContext = contextBackup;
2494  }
2495 
2496  return unmatched;
2497  };
2498 
2499  return bySet ?
2500  markFunction( superMatcher ) :
2501  superMatcher;
2502 }
2503 
2504 compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2505  var i,
2506  setMatchers = [],
2507  elementMatchers = [],
2508  cached = compilerCache[ selector + " " ];
2509 
2510  if ( !cached ) {
2511  // Generate a function of recursive functions that can be used to check each element
2512  if ( !match ) {
2513  match = tokenize( selector );
2514  }
2515  i = match.length;
2516  while ( i-- ) {
2517  cached = matcherFromTokens( match[i] );
2518  if ( cached[ expando ] ) {
2519  setMatchers.push( cached );
2520  } else {
2521  elementMatchers.push( cached );
2522  }
2523  }
2524 
2525  // Cache the compiled function
2526  cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2527 
2528  // Save selector and tokenization
2529  cached.selector = selector;
2530  }
2531  return cached;
2532 };
2533 
2543 select = Sizzle.select = function( selector, context, results, seed ) {
2544  var i, tokens, token, type, find,
2545  compiled = typeof selector === "function" && selector,
2546  match = !seed && tokenize( (selector = compiled.selector || selector) );
2547 
2548  results = results || [];
2549 
2550  // Try to minimize operations if there is only one selector in the list and no seed
2551  // (the latter of which guarantees us context)
2552  if ( match.length === 1 ) {
2553 
2554  // Reduce context if the leading compound selector is an ID
2555  tokens = match[0] = match[0].slice( 0 );
2556  if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2557  support.getById && context.nodeType === 9 && documentIsHTML &&
2558  Expr.relative[ tokens[1].type ] ) {
2559 
2560  context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2561  if ( !context ) {
2562  return results;
2563 
2564  // Precompiled matchers will still verify ancestry, so step up a level
2565  } else if ( compiled ) {
2566  context = context.parentNode;
2567  }
2568 
2569  selector = selector.slice( tokens.shift().value.length );
2570  }
2571 
2572  // Fetch a seed set for right-to-left matching
2573  i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2574  while ( i-- ) {
2575  token = tokens[i];
2576 
2577  // Abort if we hit a combinator
2578  if ( Expr.relative[ (type = token.type) ] ) {
2579  break;
2580  }
2581  if ( (find = Expr.find[ type ]) ) {
2582  // Search, expanding context for leading sibling combinators
2583  if ( (seed = find(
2584  token.matches[0].replace( runescape, funescape ),
2585  rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2586  )) ) {
2587 
2588  // If seed is empty or no tokens remain, we can return early
2589  tokens.splice( i, 1 );
2590  selector = seed.length && toSelector( tokens );
2591  if ( !selector ) {
2592  push.apply( results, seed );
2593  return results;
2594  }
2595 
2596  break;
2597  }
2598  }
2599  }
2600  }
2601 
2602  // Compile and execute a filtering function if one is not provided
2603  // Provide `match` to avoid retokenization if we modified the selector above
2604  ( compiled || compile( selector, match ) )(
2605  seed,
2606  context,
2607  !documentIsHTML,
2608  results,
2609  !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2610  );
2611  return results;
2612 };
2613 
2614 // One-time assignments
2615 
2616 // Sort stability
2617 support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2618 
2619 // Support: Chrome 14-35+
2620 // Always assume duplicates if they aren't passed to the comparison function
2621 support.detectDuplicates = !!hasDuplicate;
2622 
2623 // Initialize against the default document
2624 setDocument();
2625 
2626 // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2627 // Detached nodes confoundingly follow *each other*
2628 support.sortDetached = assert(function( div1 ) {
2629  // Should return 1, but returns 4 (following)
2630  return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2631 });
2632 
2633 // Support: IE<8
2634 // Prevent attribute/property "interpolation"
2635 // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2636 if ( !assert(function( div ) {
2637  div.innerHTML = "<a href='#'></a>";
2638  return div.firstChild.getAttribute("href") === "#" ;
2639 }) ) {
2640  addHandle( "type|href|height|width", function( elem, name, isXML ) {
2641  if ( !isXML ) {
2642  return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2643  }
2644  });
2645 }
2646 
2647 // Support: IE<9
2648 // Use defaultValue in place of getAttribute("value")
2649 if ( !support.attributes || !assert(function( div ) {
2650  div.innerHTML = "<input/>";
2651  div.firstChild.setAttribute( "value", "" );
2652  return div.firstChild.getAttribute( "value" ) === "";
2653 }) ) {
2654  addHandle( "value", function( elem, name, isXML ) {
2655  if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2656  return elem.defaultValue;
2657  }
2658  });
2659 }
2660 
2661 // Support: IE<9
2662 // Use getAttributeNode to fetch booleans when getAttribute lies
2663 if ( !assert(function( div ) {
2664  return div.getAttribute("disabled") == null;
2665 }) ) {
2666  addHandle( booleans, function( elem, name, isXML ) {
2667  var val;
2668  if ( !isXML ) {
2669  return elem[ name ] === true ? name.toLowerCase() :
2670  (val = elem.getAttributeNode( name )) && val.specified ?
2671  val.value :
2672  null;
2673  }
2674  });
2675 }
2676 
2677 return Sizzle;
2678 
2679 })( window );
2680 
2681 
2682 
2683 jQuery.find = Sizzle;
2684 jQuery.expr = Sizzle.selectors;
2685 jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2686 jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2687 jQuery.text = Sizzle.getText;
2688 jQuery.isXMLDoc = Sizzle.isXML;
2689 jQuery.contains = Sizzle.contains;
2690 
2691 
2692 
2693 var dir = function( elem, dir, until ) {
2694  var matched = [],
2695  truncate = until !== undefined;
2696 
2697  while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2698  if ( elem.nodeType === 1 ) {
2699  if ( truncate && jQuery( elem ).is( until ) ) {
2700  break;
2701  }
2702  matched.push( elem );
2703  }
2704  }
2705  return matched;
2706 };
2707 
2708 
2709 var siblings = function( n, elem ) {
2710  var matched = [];
2711 
2712  for ( ; n; n = n.nextSibling ) {
2713  if ( n.nodeType === 1 && n !== elem ) {
2714  matched.push( n );
2715  }
2716  }
2717 
2718  return matched;
2719 };
2720 
2721 
2722 var rneedsContext = jQuery.expr.match.needsContext;
2723 
2724 var rsingleTag = ( /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/ );
2725 
2726 
2727 
2728 var risSimple = /^.[^:#\[\.,]*$/;
2729 
2730 // Implement the identical functionality for filter and not
2731 function winnow( elements, qualifier, not ) {
2732  if ( jQuery.isFunction( qualifier ) ) {
2733  return jQuery.grep( elements, function( elem, i ) {
2734  /* jshint -W018 */
2735  return !!qualifier.call( elem, i, elem ) !== not;
2736  } );
2737 
2738  }
2739 
2740  if ( qualifier.nodeType ) {
2741  return jQuery.grep( elements, function( elem ) {
2742  return ( elem === qualifier ) !== not;
2743  } );
2744 
2745  }
2746 
2747  if ( typeof qualifier === "string" ) {
2748  if ( risSimple.test( qualifier ) ) {
2749  return jQuery.filter( qualifier, elements, not );
2750  }
2751 
2752  qualifier = jQuery.filter( qualifier, elements );
2753  }
2754 
2755  return jQuery.grep( elements, function( elem ) {
2756  return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
2757  } );
2758 }
2759 
2760 jQuery.filter = function( expr, elems, not ) {
2761  var elem = elems[ 0 ];
2762 
2763  if ( not ) {
2764  expr = ":not(" + expr + ")";
2765  }
2766 
2767  return elems.length === 1 && elem.nodeType === 1 ?
2768  jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2769  jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2770  return elem.nodeType === 1;
2771  } ) );
2772 };
2773 
2774 jQuery.fn.extend( {
2775  find: function( selector ) {
2776  var i,
2777  len = this.length,
2778  ret = [],
2779  self = this;
2780 
2781  if ( typeof selector !== "string" ) {
2782  return this.pushStack( jQuery( selector ).filter( function() {
2783  for ( i = 0; i < len; i++ ) {
2784  if ( jQuery.contains( self[ i ], this ) ) {
2785  return true;
2786  }
2787  }
2788  } ) );
2789  }
2790 
2791  for ( i = 0; i < len; i++ ) {
2792  jQuery.find( selector, self[ i ], ret );
2793  }
2794 
2795  // Needed because $( selector, context ) becomes $( context ).find( selector )
2796  ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
2797  ret.selector = this.selector ? this.selector + " " + selector : selector;
2798  return ret;
2799  },
2800  filter: function( selector ) {
2801  return this.pushStack( winnow( this, selector || [], false ) );
2802  },
2803  not: function( selector ) {
2804  return this.pushStack( winnow( this, selector || [], true ) );
2805  },
2806  is: function( selector ) {
2807  return !!winnow(
2808  this,
2809 
2810  // If this is a positional/relative selector, check membership in the returned set
2811  // so $("p:first").is("p:last") won't return true for a doc with two "p".
2812  typeof selector === "string" && rneedsContext.test( selector ) ?
2813  jQuery( selector ) :
2814  selector || [],
2815  false
2816  ).length;
2817  }
2818 } );
2819 
2820 
2821 // Initialize a jQuery object
2822 
2823 
2824 // A central reference to the root jQuery(document)
2825 var rootjQuery,
2826 
2827  // A simple way to check for HTML strings
2828  // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2829  // Strict HTML recognition (#11290: must start with <)
2830  rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
2831 
2832  init = jQuery.fn.init = function( selector, context, root ) {
2833  var match, elem;
2834 
2835  // HANDLE: $(""), $(null), $(undefined), $(false)
2836  if ( !selector ) {
2837  return this;
2838  }
2839 
2840  // Method init() accepts an alternate rootjQuery
2841  // so migrate can support jQuery.sub (gh-2101)
2842  root = root || rootjQuery;
2843 
2844  // Handle HTML strings
2845  if ( typeof selector === "string" ) {
2846  if ( selector[ 0 ] === "<" &&
2847  selector[ selector.length - 1 ] === ">" &&
2848  selector.length >= 3 ) {
2849 
2850  // Assume that strings that start and end with <> are HTML and skip the regex check
2851  match = [ null, selector, null ];
2852 
2853  } else {
2854  match = rquickExpr.exec( selector );
2855  }
2856 
2857  // Match html or make sure no context is specified for #id
2858  if ( match && ( match[ 1 ] || !context ) ) {
2859 
2860  // HANDLE: $(html) -> $(array)
2861  if ( match[ 1 ] ) {
2862  context = context instanceof jQuery ? context[ 0 ] : context;
2863 
2864  // Option to run scripts is true for back-compat
2865  // Intentionally let the error be thrown if parseHTML is not present
2866  jQuery.merge( this, jQuery.parseHTML(
2867  match[ 1 ],
2868  context && context.nodeType ? context.ownerDocument || context : document,
2869  true
2870  ) );
2871 
2872  // HANDLE: $(html, props)
2873  if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
2874  for ( match in context ) {
2875 
2876  // Properties of context are called as methods if possible
2877  if ( jQuery.isFunction( this[ match ] ) ) {
2878  this[ match ]( context[ match ] );
2879 
2880  // ...and otherwise set as attributes
2881  } else {
2882  this.attr( match, context[ match ] );
2883  }
2884  }
2885  }
2886 
2887  return this;
2888 
2889  // HANDLE: $(#id)
2890  } else {
2891  elem = document.getElementById( match[ 2 ] );
2892 
2893  // Support: Blackberry 4.6
2894  // gEBID returns nodes no longer in the document (#6963)
2895  if ( elem && elem.parentNode ) {
2896 
2897  // Inject the element directly into the jQuery object
2898  this.length = 1;
2899  this[ 0 ] = elem;
2900  }
2901 
2902  this.context = document;
2903  this.selector = selector;
2904  return this;
2905  }
2906 
2907  // HANDLE: $(expr, $(...))
2908  } else if ( !context || context.jquery ) {
2909  return ( context || root ).find( selector );
2910 
2911  // HANDLE: $(expr, context)
2912  // (which is just equivalent to: $(context).find(expr)
2913  } else {
2914  return this.constructor( context ).find( selector );
2915  }
2916 
2917  // HANDLE: $(DOMElement)
2918  } else if ( selector.nodeType ) {
2919  this.context = this[ 0 ] = selector;
2920  this.length = 1;
2921  return this;
2922 
2923  // HANDLE: $(function)
2924  // Shortcut for document ready
2925  } else if ( jQuery.isFunction( selector ) ) {
2926  return root.ready !== undefined ?
2927  root.ready( selector ) :
2928 
2929  // Execute immediately if ready is not present
2930  selector( jQuery );
2931  }
2932 
2933  if ( selector.selector !== undefined ) {
2934  this.selector = selector.selector;
2935  this.context = selector.context;
2936  }
2937 
2938  return jQuery.makeArray( selector, this );
2939  };
2940 
2941 // Give the init function the jQuery prototype for later instantiation
2942 init.prototype = jQuery.fn;
2943 
2944 // Initialize central reference
2945 rootjQuery = jQuery( document );
2946 
2947 
2948 var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2949 
2950  // Methods guaranteed to produce a unique set when starting from a unique set
2951  guaranteedUnique = {
2952  children: true,
2953  contents: true,
2954  next: true,
2955  prev: true
2956  };
2957 
2958 jQuery.fn.extend( {
2959  has: function( target ) {
2960  var targets = jQuery( target, this ),
2961  l = targets.length;
2962 
2963  return this.filter( function() {
2964  var i = 0;
2965  for ( ; i < l; i++ ) {
2966  if ( jQuery.contains( this, targets[ i ] ) ) {
2967  return true;
2968  }
2969  }
2970  } );
2971  },
2972 
2973  closest: function( selectors, context ) {
2974  var cur,
2975  i = 0,
2976  l = this.length,
2977  matched = [],
2978  pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
2979  jQuery( selectors, context || this.context ) :
2980  0;
2981 
2982  for ( ; i < l; i++ ) {
2983  for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
2984 
2985  // Always skip document fragments
2986  if ( cur.nodeType < 11 && ( pos ?
2987  pos.index( cur ) > -1 :
2988 
2989  // Don't pass non-elements to Sizzle
2990  cur.nodeType === 1 &&
2991  jQuery.find.matchesSelector( cur, selectors ) ) ) {
2992 
2993  matched.push( cur );
2994  break;
2995  }
2996  }
2997  }
2998 
2999  return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3000  },
3001 
3002  // Determine the position of an element within the set
3003  index: function( elem ) {
3004 
3005  // No argument, return index in parent
3006  if ( !elem ) {
3007  return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3008  }
3009 
3010  // Index in selector
3011  if ( typeof elem === "string" ) {
3012  return indexOf.call( jQuery( elem ), this[ 0 ] );
3013  }
3014 
3015  // Locate the position of the desired element
3016  return indexOf.call( this,
3017 
3018  // If it receives a jQuery object, the first element is used
3019  elem.jquery ? elem[ 0 ] : elem
3020  );
3021  },
3022 
3023  add: function( selector, context ) {
3024  return this.pushStack(
3025  jQuery.uniqueSort(
3026  jQuery.merge( this.get(), jQuery( selector, context ) )
3027  )
3028  );
3029  },
3030 
3031  addBack: function( selector ) {
3032  return this.add( selector == null ?
3033  this.prevObject : this.prevObject.filter( selector )
3034  );
3035  }
3036 } );
3037 
3038 function sibling( cur, dir ) {
3039  while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3040  return cur;
3041 }
3042 
3043 jQuery.each( {
3044  parent: function( elem ) {
3045  var parent = elem.parentNode;
3046  return parent && parent.nodeType !== 11 ? parent : null;
3047  },
3048  parents: function( elem ) {
3049  return dir( elem, "parentNode" );
3050  },
3051  parentsUntil: function( elem, i, until ) {
3052  return dir( elem, "parentNode", until );
3053  },
3054  next: function( elem ) {
3055  return sibling( elem, "nextSibling" );
3056  },
3057  prev: function( elem ) {
3058  return sibling( elem, "previousSibling" );
3059  },
3060  nextAll: function( elem ) {
3061  return dir( elem, "nextSibling" );
3062  },
3063  prevAll: function( elem ) {
3064  return dir( elem, "previousSibling" );
3065  },
3066  nextUntil: function( elem, i, until ) {
3067  return dir( elem, "nextSibling", until );
3068  },
3069  prevUntil: function( elem, i, until ) {
3070  return dir( elem, "previousSibling", until );
3071  },
3072  siblings: function( elem ) {
3073  return siblings( ( elem.parentNode || {} ).firstChild, elem );
3074  },
3075  children: function( elem ) {
3076  return siblings( elem.firstChild );
3077  },
3078  contents: function( elem ) {
3079  return elem.contentDocument || jQuery.merge( [], elem.childNodes );
3080  }
3081 }, function( name, fn ) {
3082  jQuery.fn[ name ] = function( until, selector ) {
3083  var matched = jQuery.map( this, fn, until );
3084 
3085  if ( name.slice( -5 ) !== "Until" ) {
3086  selector = until;
3087  }
3088 
3089  if ( selector && typeof selector === "string" ) {
3090  matched = jQuery.filter( selector, matched );
3091  }
3092 
3093  if ( this.length > 1 ) {
3094 
3095  // Remove duplicates
3096  if ( !guaranteedUnique[ name ] ) {
3097  jQuery.uniqueSort( matched );
3098  }
3099 
3100  // Reverse order for parents* and prev-derivatives
3101  if ( rparentsprev.test( name ) ) {
3102  matched.reverse();
3103  }
3104  }
3105 
3106  return this.pushStack( matched );
3107  };
3108 } );
3109 var rnotwhite = ( /\S+/g );
3110 
3111 
3112 
3113 // Convert String-formatted options into Object-formatted ones
3114 function createOptions( options ) {
3115  var object = {};
3116  jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
3117  object[ flag ] = true;
3118  } );
3119  return object;
3120 }
3121 
3122 /*
3123  * Create a callback list using the following parameters:
3124  *
3125  * options: an optional list of space-separated options that will change how
3126  * the callback list behaves or a more traditional option object
3127  *
3128  * By default a callback list will act like an event callback list and can be
3129  * "fired" multiple times.
3130  *
3131  * Possible options:
3132  *
3133  * once: will ensure the callback list can only be fired once (like a Deferred)
3134  *
3135  * memory: will keep track of previous values and will call any callback added
3136  * after the list has been fired right away with the latest "memorized"
3137  * values (like a Deferred)
3138  *
3139  * unique: will ensure a callback can only be added once (no duplicate in the list)
3140  *
3141  * stopOnFalse: interrupt callings when a callback returns false
3142  *
3143  */
3144 jQuery.Callbacks = function( options ) {
3145 
3146  // Convert options from String-formatted to Object-formatted if needed
3147  // (we check in cache first)
3148  options = typeof options === "string" ?
3149  createOptions( options ) :
3150  jQuery.extend( {}, options );
3151 
3152  var // Flag to know if list is currently firing
3153  firing,
3154 
3155  // Last fire value for non-forgettable lists
3156  memory,
3157 
3158  // Flag to know if list was already fired
3159  fired,
3160 
3161  // Flag to prevent firing
3162  locked,
3163 
3164  // Actual callback list
3165  list = [],
3166 
3167  // Queue of execution data for repeatable lists
3168  queue = [],
3169 
3170  // Index of currently firing callback (modified by add/remove as needed)
3171  firingIndex = -1,
3172 
3173  // Fire callbacks
3174  fire = function() {
3175 
3176  // Enforce single-firing
3177  locked = options.once;
3178 
3179  // Execute callbacks for all pending executions,
3180  // respecting firingIndex overrides and runtime changes
3181  fired = firing = true;
3182  for ( ; queue.length; firingIndex = -1 ) {
3183  memory = queue.shift();
3184  while ( ++firingIndex < list.length ) {
3185 
3186  // Run callback and check for early termination
3187  if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3188  options.stopOnFalse ) {
3189 
3190  // Jump to end and forget the data so .add doesn't re-fire
3191  firingIndex = list.length;
3192  memory = false;
3193  }
3194  }
3195  }
3196 
3197  // Forget the data if we're done with it
3198  if ( !options.memory ) {
3199  memory = false;
3200  }
3201 
3202  firing = false;
3203 
3204  // Clean up if we're done firing for good
3205  if ( locked ) {
3206 
3207  // Keep an empty list if we have data for future add calls
3208  if ( memory ) {
3209  list = [];
3210 
3211  // Otherwise, this object is spent
3212  } else {
3213  list = "";
3214  }
3215  }
3216  },
3217 
3218  // Actual Callbacks object
3219  self = {
3220 
3221  // Add a callback or a collection of callbacks to the list
3222  add: function() {
3223  if ( list ) {
3224 
3225  // If we have memory from a past run, we should fire after adding
3226  if ( memory && !firing ) {
3227  firingIndex = list.length - 1;
3228  queue.push( memory );
3229  }
3230 
3231  ( function add( args ) {
3232  jQuery.each( args, function( _, arg ) {
3233  if ( jQuery.isFunction( arg ) ) {
3234  if ( !options.unique || !self.has( arg ) ) {
3235  list.push( arg );
3236  }
3237  } else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
3238 
3239  // Inspect recursively
3240  add( arg );
3241  }
3242  } );
3243  } )( arguments );
3244 
3245  if ( memory && !firing ) {
3246  fire();
3247  }
3248  }
3249  return this;
3250  },
3251 
3252  // Remove a callback from the list
3253  remove: function() {
3254  jQuery.each( arguments, function( _, arg ) {
3255  var index;
3256  while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3257  list.splice( index, 1 );
3258 
3259  // Handle firing indexes
3260  if ( index <= firingIndex ) {
3261  firingIndex--;
3262  }
3263  }
3264  } );
3265  return this;
3266  },
3267 
3268  // Check if a given callback is in the list.
3269  // If no argument is given, return whether or not list has callbacks attached.
3270  has: function( fn ) {
3271  return fn ?
3272  jQuery.inArray( fn, list ) > -1 :
3273  list.length > 0;
3274  },
3275 
3276  // Remove all callbacks from the list
3277  empty: function() {
3278  if ( list ) {
3279  list = [];
3280  }
3281  return this;
3282  },
3283 
3284  // Disable .fire and .add
3285  // Abort any current/pending executions
3286  // Clear all callbacks and values
3287  disable: function() {
3288  locked = queue = [];
3289  list = memory = "";
3290  return this;
3291  },
3292  disabled: function() {
3293  return !list;
3294  },
3295 
3296  // Disable .fire
3297  // Also disable .add unless we have memory (since it would have no effect)
3298  // Abort any pending executions
3299  lock: function() {
3300  locked = queue = [];
3301  if ( !memory ) {
3302  list = memory = "";
3303  }
3304  return this;
3305  },
3306  locked: function() {
3307  return !!locked;
3308  },
3309 
3310  // Call all callbacks with the given context and arguments
3311  fireWith: function( context, args ) {
3312  if ( !locked ) {
3313  args = args || [];
3314  args = [ context, args.slice ? args.slice() : args ];
3315  queue.push( args );
3316  if ( !firing ) {
3317  fire();
3318  }
3319  }
3320  return this;
3321  },
3322 
3323  // Call all the callbacks with the given arguments
3324  fire: function() {
3325  self.fireWith( this, arguments );
3326  return this;
3327  },
3328 
3329  // To know if the callbacks have already been called at least once
3330  fired: function() {
3331  return !!fired;
3332  }
3333  };
3334 
3335  return self;
3336 };
3337 
3338 
3339 jQuery.extend( {
3340 
3341  Deferred: function( func ) {
3342  var tuples = [
3343 
3344  // action, add listener, listener list, final state
3345  [ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
3346  [ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
3347  [ "notify", "progress", jQuery.Callbacks( "memory" ) ]
3348  ],
3349  state = "pending",
3350  promise = {
3351  state: function() {
3352  return state;
3353  },
3354  always: function() {
3355  deferred.done( arguments ).fail( arguments );
3356  return this;
3357  },
3358  then: function( /* fnDone, fnFail, fnProgress */ ) {
3359  var fns = arguments;
3360  return jQuery.Deferred( function( newDefer ) {
3361  jQuery.each( tuples, function( i, tuple ) {
3362  var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3363 
3364  // deferred[ done | fail | progress ] for forwarding actions to newDefer
3365  deferred[ tuple[ 1 ] ]( function() {
3366  var returned = fn && fn.apply( this, arguments );
3367  if ( returned && jQuery.isFunction( returned.promise ) ) {
3368  returned.promise()
3369  .progress( newDefer.notify )
3370  .done( newDefer.resolve )
3371  .fail( newDefer.reject );
3372  } else {
3373  newDefer[ tuple[ 0 ] + "With" ](
3374  this === promise ? newDefer.promise() : this,
3375  fn ? [ returned ] : arguments
3376  );
3377  }
3378  } );
3379  } );
3380  fns = null;
3381  } ).promise();
3382  },
3383 
3384  // Get a promise for this deferred
3385  // If obj is provided, the promise aspect is added to the object
3386  promise: function( obj ) {
3387  return obj != null ? jQuery.extend( obj, promise ) : promise;
3388  }
3389  },
3390  deferred = {};
3391 
3392  // Keep pipe for back-compat
3393  promise.pipe = promise.then;
3394 
3395  // Add list-specific methods
3396  jQuery.each( tuples, function( i, tuple ) {
3397  var list = tuple[ 2 ],
3398  stateString = tuple[ 3 ];
3399 
3400  // promise[ done | fail | progress ] = list.add
3401  promise[ tuple[ 1 ] ] = list.add;
3402 
3403  // Handle state
3404  if ( stateString ) {
3405  list.add( function() {
3406 
3407  // state = [ resolved | rejected ]
3408  state = stateString;
3409 
3410  // [ reject_list | resolve_list ].disable; progress_list.lock
3411  }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3412  }
3413 
3414  // deferred[ resolve | reject | notify ]
3415  deferred[ tuple[ 0 ] ] = function() {
3416  deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
3417  return this;
3418  };
3419  deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3420  } );
3421 
3422  // Make the deferred a promise
3423  promise.promise( deferred );
3424 
3425  // Call given func if any
3426  if ( func ) {
3427  func.call( deferred, deferred );
3428  }
3429 
3430  // All done!
3431  return deferred;
3432  },
3433 
3434  // Deferred helper
3435  when: function( subordinate /* , ..., subordinateN */ ) {
3436  var i = 0,
3437  resolveValues = slice.call( arguments ),
3438  length = resolveValues.length,
3439 
3440  // the count of uncompleted subordinates
3441  remaining = length !== 1 ||
3442  ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
3443 
3444  // the master Deferred.
3445  // If resolveValues consist of only a single Deferred, just use that.
3446  deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
3447 
3448  // Update function for both resolve and progress values
3449  updateFunc = function( i, contexts, values ) {
3450  return function( value ) {
3451  contexts[ i ] = this;
3452  values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
3453  if ( values === progressValues ) {
3454  deferred.notifyWith( contexts, values );
3455  } else if ( !( --remaining ) ) {
3456  deferred.resolveWith( contexts, values );
3457  }
3458  };
3459  },
3460 
3461  progressValues, progressContexts, resolveContexts;
3462 
3463  // Add listeners to Deferred subordinates; treat others as resolved
3464  if ( length > 1 ) {
3465  progressValues = new Array( length );
3466  progressContexts = new Array( length );
3467  resolveContexts = new Array( length );
3468  for ( ; i < length; i++ ) {
3469  if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
3470  resolveValues[ i ].promise()
3471  .progress( updateFunc( i, progressContexts, progressValues ) )
3472  .done( updateFunc( i, resolveContexts, resolveValues ) )
3473  .fail( deferred.reject );
3474  } else {
3475  --remaining;
3476  }
3477  }
3478  }
3479 
3480  // If we're not waiting on anything, resolve the master
3481  if ( !remaining ) {
3482  deferred.resolveWith( resolveContexts, resolveValues );
3483  }
3484 
3485  return deferred.promise();
3486  }
3487 } );
3488 
3489 
3490 // The deferred used on DOM ready
3491 var readyList;
3492 
3493 jQuery.fn.ready = function( fn ) {
3494 
3495  // Add the callback
3496  jQuery.ready.promise().done( fn );
3497 
3498  return this;
3499 };
3500 
3501 jQuery.extend( {
3502 
3503  // Is the DOM ready to be used? Set to true once it occurs.
3504  isReady: false,
3505 
3506  // A counter to track how many items to wait for before
3507  // the ready event fires. See #6781
3508  readyWait: 1,
3509 
3510  // Hold (or release) the ready event
3511  holdReady: function( hold ) {
3512  if ( hold ) {
3513  jQuery.readyWait++;
3514  } else {
3515  jQuery.ready( true );
3516  }
3517  },
3518 
3519  // Handle when the DOM is ready
3520  ready: function( wait ) {
3521 
3522  // Abort if there are pending holds or we're already ready
3523  if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
3524  return;
3525  }
3526 
3527  // Remember that the DOM is ready
3528  jQuery.isReady = true;
3529 
3530  // If a normal DOM Ready event fired, decrement, and wait if need be
3531  if ( wait !== true && --jQuery.readyWait > 0 ) {
3532  return;
3533  }
3534 
3535  // If there are functions bound, to execute
3536  readyList.resolveWith( document, [ jQuery ] );
3537 
3538  // Trigger any bound ready events
3539  if ( jQuery.fn.triggerHandler ) {
3540  jQuery( document ).triggerHandler( "ready" );
3541  jQuery( document ).off( "ready" );
3542  }
3543  }
3544 } );
3545 
3549 function completed() {
3550  document.removeEventListener( "DOMContentLoaded", completed );
3551  window.removeEventListener( "load", completed );
3552  jQuery.ready();
3553 }
3554 
3555 jQuery.ready.promise = function( obj ) {
3556  if ( !readyList ) {
3557 
3558  readyList = jQuery.Deferred();
3559 
3560  // Catch cases where $(document).ready() is called
3561  // after the browser event has already occurred.
3562  // Support: IE9-10 only
3563  // Older IE sometimes signals "interactive" too soon
3564  if ( document.readyState === "complete" ||
3565  ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
3566 
3567  // Handle it asynchronously to allow scripts the opportunity to delay ready
3568  window.setTimeout( jQuery.ready );
3569 
3570  } else {
3571 
3572  // Use the handy event callback
3573  document.addEventListener( "DOMContentLoaded", completed );
3574 
3575  // A fallback to window.onload, that will always work
3576  window.addEventListener( "load", completed );
3577  }
3578  }
3579  return readyList.promise( obj );
3580 };
3581 
3582 // Kick off the DOM ready check even if the user does not
3583 jQuery.ready.promise();
3584 
3585 
3586 
3587 
3588 // Multifunctional method to get and set values of a collection
3589 // The value/s can optionally be executed if it's a function
3590 var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
3591  var i = 0,
3592  len = elems.length,
3593  bulk = key == null;
3594 
3595  // Sets many values
3596  if ( jQuery.type( key ) === "object" ) {
3597  chainable = true;
3598  for ( i in key ) {
3599  access( elems, fn, i, key[ i ], true, emptyGet, raw );
3600  }
3601 
3602  // Sets one value
3603  } else if ( value !== undefined ) {
3604  chainable = true;
3605 
3606  if ( !jQuery.isFunction( value ) ) {
3607  raw = true;
3608  }
3609 
3610  if ( bulk ) {
3611 
3612  // Bulk operations run against the entire set
3613  if ( raw ) {
3614  fn.call( elems, value );
3615  fn = null;
3616 
3617  // ...except when executing function values
3618  } else {
3619  bulk = fn;
3620  fn = function( elem, key, value ) {
3621  return bulk.call( jQuery( elem ), value );
3622  };
3623  }
3624  }
3625 
3626  if ( fn ) {
3627  for ( ; i < len; i++ ) {
3628  fn(
3629  elems[ i ], key, raw ?
3630  value :
3631  value.call( elems[ i ], i, fn( elems[ i ], key ) )
3632  );
3633  }
3634  }
3635  }
3636 
3637  return chainable ?
3638  elems :
3639 
3640  // Gets
3641  bulk ?
3642  fn.call( elems ) :
3643  len ? fn( elems[ 0 ], key ) : emptyGet;
3644 };
3645 var acceptData = function( owner ) {
3646 
3647  // Accepts only:
3648  // - Node
3649  // - Node.ELEMENT_NODE
3650  // - Node.DOCUMENT_NODE
3651  // - Object
3652  // - Any
3653  /* jshint -W018 */
3654  return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
3655 };
3656 
3657 
3658 
3659 
3660 function Data() {
3661  this.expando = jQuery.expando + Data.uid++;
3662 }
3663 
3664 Data.uid = 1;
3665 
3666 Data.prototype = {
3667 
3668  register: function( owner, initial ) {
3669  var value = initial || {};
3670 
3671  // If it is a node unlikely to be stringify-ed or looped over
3672  // use plain assignment
3673  if ( owner.nodeType ) {
3674  owner[ this.expando ] = value;
3675 
3676  // Otherwise secure it in a non-enumerable, non-writable property
3677  // configurability must be true to allow the property to be
3678  // deleted with the delete operator
3679  } else {
3680  Object.defineProperty( owner, this.expando, {
3681  value: value,
3682  writable: true,
3683  configurable: true
3684  } );
3685  }
3686  return owner[ this.expando ];
3687  },
3688  cache: function( owner ) {
3689 
3690  // We can accept data for non-element nodes in modern browsers,
3691  // but we should not, see #8335.
3692  // Always return an empty object.
3693  if ( !acceptData( owner ) ) {
3694  return {};
3695  }
3696 
3697  // Check if the owner object already has a cache
3698  var value = owner[ this.expando ];
3699 
3700  // If not, create one
3701  if ( !value ) {
3702  value = {};
3703 
3704  // We can accept data for non-element nodes in modern browsers,
3705  // but we should not, see #8335.
3706  // Always return an empty object.
3707  if ( acceptData( owner ) ) {
3708 
3709  // If it is a node unlikely to be stringify-ed or looped over
3710  // use plain assignment
3711  if ( owner.nodeType ) {
3712  owner[ this.expando ] = value;
3713 
3714  // Otherwise secure it in a non-enumerable property
3715  // configurable must be true to allow the property to be
3716  // deleted when data is removed
3717  } else {
3718  Object.defineProperty( owner, this.expando, {
3719  value: value,
3720  configurable: true
3721  } );
3722  }
3723  }
3724  }
3725 
3726  return value;
3727  },
3728  set: function( owner, data, value ) {
3729  var prop,
3730  cache = this.cache( owner );
3731 
3732  // Handle: [ owner, key, value ] args
3733  if ( typeof data === "string" ) {
3734  cache[ data ] = value;
3735 
3736  // Handle: [ owner, { properties } ] args
3737  } else {
3738 
3739  // Copy the properties one-by-one to the cache object
3740  for ( prop in data ) {
3741  cache[ prop ] = data[ prop ];
3742  }
3743  }
3744  return cache;
3745  },
3746  get: function( owner, key ) {
3747  return key === undefined ?
3748  this.cache( owner ) :
3749  owner[ this.expando ] && owner[ this.expando ][ key ];
3750  },
3751  access: function( owner, key, value ) {
3752  var stored;
3753 
3754  // In cases where either:
3755  //
3756  // 1. No key was specified
3757  // 2. A string key was specified, but no value provided
3758  //
3759  // Take the "read" path and allow the get method to determine
3760  // which value to return, respectively either:
3761  //
3762  // 1. The entire cache object
3763  // 2. The data stored at the key
3764  //
3765  if ( key === undefined ||
3766  ( ( key && typeof key === "string" ) && value === undefined ) ) {
3767 
3768  stored = this.get( owner, key );
3769 
3770  return stored !== undefined ?
3771  stored : this.get( owner, jQuery.camelCase( key ) );
3772  }
3773 
3774  // When the key is not a string, or both a key and value
3775  // are specified, set or extend (existing objects) with either:
3776  //
3777  // 1. An object of properties
3778  // 2. A key and value
3779  //
3780  this.set( owner, key, value );
3781 
3782  // Since the "set" path can have two possible entry points
3783  // return the expected data based on which path was taken[*]
3784  return value !== undefined ? value : key;
3785  },
3786  remove: function( owner, key ) {
3787  var i, name, camel,
3788  cache = owner[ this.expando ];
3789 
3790  if ( cache === undefined ) {
3791  return;
3792  }
3793 
3794  if ( key === undefined ) {
3795  this.register( owner );
3796 
3797  } else {
3798 
3799  // Support array or space separated string of keys
3800  if ( jQuery.isArray( key ) ) {
3801 
3802  // If "name" is an array of keys...
3803  // When data is initially created, via ("key", "val") signature,
3804  // keys will be converted to camelCase.
3805  // Since there is no way to tell _how_ a key was added, remove
3806  // both plain key and camelCase key. #12786
3807  // This will only penalize the array argument path.
3808  name = key.concat( key.map( jQuery.camelCase ) );
3809  } else {
3810  camel = jQuery.camelCase( key );
3811 
3812  // Try the string as a key before any manipulation
3813  if ( key in cache ) {
3814  name = [ key, camel ];
3815  } else {
3816 
3817  // If a key with the spaces exists, use it.
3818  // Otherwise, create an array by matching non-whitespace
3819  name = camel;
3820  name = name in cache ?
3821  [ name ] : ( name.match( rnotwhite ) || [] );
3822  }
3823  }
3824 
3825  i = name.length;
3826 
3827  while ( i-- ) {
3828  delete cache[ name[ i ] ];
3829  }
3830  }
3831 
3832  // Remove the expando if there's no more data
3833  if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
3834 
3835  // Support: Chrome <= 35-45+
3836  // Webkit & Blink performance suffers when deleting properties
3837  // from DOM nodes, so set to undefined instead
3838  // https://code.google.com/p/chromium/issues/detail?id=378607
3839  if ( owner.nodeType ) {
3840  owner[ this.expando ] = undefined;
3841  } else {
3842  delete owner[ this.expando ];
3843  }
3844  }
3845  },
3846  hasData: function( owner ) {
3847  var cache = owner[ this.expando ];
3848  return cache !== undefined && !jQuery.isEmptyObject( cache );
3849  }
3850 };
3851 var dataPriv = new Data();
3852 
3853 var dataUser = new Data();
3854 
3855 
3856 
3857 // Implementation Summary
3858 //
3859 // 1. Enforce API surface and semantic compatibility with 1.9.x branch
3860 // 2. Improve the module's maintainability by reducing the storage
3861 // paths to a single mechanism.
3862 // 3. Use the same single mechanism to support "private" and "user" data.
3863 // 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
3864 // 5. Avoid exposing implementation details on user objects (eg. expando properties)
3865 // 6. Provide a clear path for implementation upgrade to WeakMap in 2014
3866 
3867 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
3868  rmultiDash = /[A-Z]/g;
3869 
3870 function dataAttr( elem, key, data ) {
3871  var name;
3872 
3873  // If nothing was found internally, try to fetch any
3874  // data from the HTML5 data-* attribute
3875  if ( data === undefined && elem.nodeType === 1 ) {
3876  name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
3877  data = elem.getAttribute( name );
3878 
3879  if ( typeof data === "string" ) {
3880  try {
3881  data = data === "true" ? true :
3882  data === "false" ? false :
3883  data === "null" ? null :
3884 
3885  // Only convert to a number if it doesn't change the string
3886  +data + "" === data ? +data :
3887  rbrace.test( data ) ? jQuery.parseJSON( data ) :
3888  data;
3889  } catch ( e ) {}
3890 
3891  // Make sure we set the data so it isn't changed later
3892  dataUser.set( elem, key, data );
3893  } else {
3894  data = undefined;
3895  }
3896  }
3897  return data;
3898 }
3899 
3900 jQuery.extend( {
3901  hasData: function( elem ) {
3902  return dataUser.hasData( elem ) || dataPriv.hasData( elem );
3903  },
3904 
3905  data: function( elem, name, data ) {
3906  return dataUser.access( elem, name, data );
3907  },
3908 
3909  removeData: function( elem, name ) {
3910  dataUser.remove( elem, name );
3911  },
3912 
3913  // TODO: Now that all calls to _data and _removeData have been replaced
3914  // with direct calls to dataPriv methods, these can be deprecated.
3915  _data: function( elem, name, data ) {
3916  return dataPriv.access( elem, name, data );
3917  },
3918 
3919  _removeData: function( elem, name ) {
3920  dataPriv.remove( elem, name );
3921  }
3922 } );
3923 
3924 jQuery.fn.extend( {
3925  data: function( key, value ) {
3926  var i, name, data,
3927  elem = this[ 0 ],
3928  attrs = elem && elem.attributes;
3929 
3930  // Gets all values
3931  if ( key === undefined ) {
3932  if ( this.length ) {
3933  data = dataUser.get( elem );
3934 
3935  if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
3936  i = attrs.length;
3937  while ( i-- ) {
3938 
3939  // Support: IE11+
3940  // The attrs elements can be null (#14894)
3941  if ( attrs[ i ] ) {
3942  name = attrs[ i ].name;
3943  if ( name.indexOf( "data-" ) === 0 ) {
3944  name = jQuery.camelCase( name.slice( 5 ) );
3945  dataAttr( elem, name, data[ name ] );
3946  }
3947  }
3948  }
3949  dataPriv.set( elem, "hasDataAttrs", true );
3950  }
3951  }
3952 
3953  return data;
3954  }
3955 
3956  // Sets multiple values
3957  if ( typeof key === "object" ) {
3958  return this.each( function() {
3959  dataUser.set( this, key );
3960  } );
3961  }
3962 
3963  return access( this, function( value ) {
3964  var data, camelKey;
3965 
3966  // The calling jQuery object (element matches) is not empty
3967  // (and therefore has an element appears at this[ 0 ]) and the
3968  // `value` parameter was not undefined. An empty jQuery object
3969  // will result in `undefined` for elem = this[ 0 ] which will
3970  // throw an exception if an attempt to read a data cache is made.
3971  if ( elem && value === undefined ) {
3972 
3973  // Attempt to get data from the cache
3974  // with the key as-is
3975  data = dataUser.get( elem, key ) ||
3976 
3977  // Try to find dashed key if it exists (gh-2779)
3978  // This is for 2.2.x only
3979  dataUser.get( elem, key.replace( rmultiDash, "-$&" ).toLowerCase() );
3980 
3981  if ( data !== undefined ) {
3982  return data;
3983  }
3984 
3985  camelKey = jQuery.camelCase( key );
3986 
3987  // Attempt to get data from the cache
3988  // with the key camelized
3989  data = dataUser.get( elem, camelKey );
3990  if ( data !== undefined ) {
3991  return data;
3992  }
3993 
3994  // Attempt to "discover" the data in
3995  // HTML5 custom data-* attrs
3996  data = dataAttr( elem, camelKey, undefined );
3997  if ( data !== undefined ) {
3998  return data;
3999  }
4000 
4001  // We tried really hard, but the data doesn't exist.
4002  return;
4003  }
4004 
4005  // Set the data...
4006  camelKey = jQuery.camelCase( key );
4007  this.each( function() {
4008 
4009  // First, attempt to store a copy or reference of any
4010  // data that might've been store with a camelCased key.
4011  var data = dataUser.get( this, camelKey );
4012 
4013  // For HTML5 data-* attribute interop, we have to
4014  // store property names with dashes in a camelCase form.
4015  // This might not apply to all properties...*
4016  dataUser.set( this, camelKey, value );
4017 
4018  // *... In the case of properties that might _actually_
4019  // have dashes, we need to also store a copy of that
4020  // unchanged property.
4021  if ( key.indexOf( "-" ) > -1 && data !== undefined ) {
4022  dataUser.set( this, key, value );
4023  }
4024  } );
4025  }, null, value, arguments.length > 1, null, true );
4026  },
4027 
4028  removeData: function( key ) {
4029  return this.each( function() {
4030  dataUser.remove( this, key );
4031  } );
4032  }
4033 } );
4034 
4035 
4036 jQuery.extend( {
4037  queue: function( elem, type, data ) {
4038  var queue;
4039 
4040  if ( elem ) {
4041  type = ( type || "fx" ) + "queue";
4042  queue = dataPriv.get( elem, type );
4043 
4044  // Speed up dequeue by getting out quickly if this is just a lookup
4045  if ( data ) {
4046  if ( !queue || jQuery.isArray( data ) ) {
4047  queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
4048  } else {
4049  queue.push( data );
4050  }
4051  }
4052  return queue || [];
4053  }
4054  },
4055 
4056  dequeue: function( elem, type ) {
4057  type = type || "fx";
4058 
4059  var queue = jQuery.queue( elem, type ),
4060  startLength = queue.length,
4061  fn = queue.shift(),
4062  hooks = jQuery._queueHooks( elem, type ),
4063  next = function() {
4064  jQuery.dequeue( elem, type );
4065  };
4066 
4067  // If the fx queue is dequeued, always remove the progress sentinel
4068  if ( fn === "inprogress" ) {
4069  fn = queue.shift();
4070  startLength--;
4071  }
4072 
4073  if ( fn ) {
4074 
4075  // Add a progress sentinel to prevent the fx queue from being
4076  // automatically dequeued
4077  if ( type === "fx" ) {
4078  queue.unshift( "inprogress" );
4079  }
4080 
4081  // Clear up the last queue stop function
4082  delete hooks.stop;
4083  fn.call( elem, next, hooks );
4084  }
4085 
4086  if ( !startLength && hooks ) {
4087  hooks.empty.fire();
4088  }
4089  },
4090 
4091  // Not public - generate a queueHooks object, or return the current one
4092  _queueHooks: function( elem, type ) {
4093  var key = type + "queueHooks";
4094  return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
4095  empty: jQuery.Callbacks( "once memory" ).add( function() {
4096  dataPriv.remove( elem, [ type + "queue", key ] );
4097  } )
4098  } );
4099  }
4100 } );
4101 
4102 jQuery.fn.extend( {
4103  queue: function( type, data ) {
4104  var setter = 2;
4105 
4106  if ( typeof type !== "string" ) {
4107  data = type;
4108  type = "fx";
4109  setter--;
4110  }
4111 
4112  if ( arguments.length < setter ) {
4113  return jQuery.queue( this[ 0 ], type );
4114  }
4115 
4116  return data === undefined ?
4117  this :
4118  this.each( function() {
4119  var queue = jQuery.queue( this, type, data );
4120 
4121  // Ensure a hooks for this queue
4122  jQuery._queueHooks( this, type );
4123 
4124  if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4125  jQuery.dequeue( this, type );
4126  }
4127  } );
4128  },
4129  dequeue: function( type ) {
4130  return this.each( function() {
4131  jQuery.dequeue( this, type );
4132  } );
4133  },
4134  clearQueue: function( type ) {
4135  return this.queue( type || "fx", [] );
4136  },
4137 
4138  // Get a promise resolved when queues of a certain type
4139  // are emptied (fx is the type by default)
4140  promise: function( type, obj ) {
4141  var tmp,
4142  count = 1,
4143  defer = jQuery.Deferred(),
4144  elements = this,
4145  i = this.length,
4146  resolve = function() {
4147  if ( !( --count ) ) {
4148  defer.resolveWith( elements, [ elements ] );
4149  }
4150  };
4151 
4152  if ( typeof type !== "string" ) {
4153  obj = type;
4154  type = undefined;
4155  }
4156  type = type || "fx";
4157 
4158  while ( i-- ) {
4159  tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
4160  if ( tmp && tmp.empty ) {
4161  count++;
4162  tmp.empty.add( resolve );
4163  }
4164  }
4165  resolve();
4166  return defer.promise( obj );
4167  }
4168 } );
4169 var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4170 
4171 var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4172 
4173 
4174 var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4175 
4176 var isHidden = function( elem, el ) {
4177 
4178  // isHidden might be called from jQuery#filter function;
4179  // in that case, element will be second argument
4180  elem = el || elem;
4181  return jQuery.css( elem, "display" ) === "none" ||
4182  !jQuery.contains( elem.ownerDocument, elem );
4183  };
4184 
4185 
4186 
4187 function adjustCSS( elem, prop, valueParts, tween ) {
4188  var adjusted,
4189  scale = 1,
4190  maxIterations = 20,
4191  currentValue = tween ?
4192  function() { return tween.cur(); } :
4193  function() { return jQuery.css( elem, prop, "" ); },
4194  initial = currentValue(),
4195  unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4196 
4197  // Starting value computation is required for potential unit mismatches
4198  initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4199  rcssNum.exec( jQuery.css( elem, prop ) );
4200 
4201  if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4202 
4203  // Trust units reported by jQuery.css
4204  unit = unit || initialInUnit[ 3 ];
4205 
4206  // Make sure we update the tween properties later on
4207  valueParts = valueParts || [];
4208 
4209  // Iteratively approximate from a nonzero starting point
4210  initialInUnit = +initial || 1;
4211 
4212  do {
4213 
4214  // If previous iteration zeroed out, double until we get *something*.
4215  // Use string for doubling so we don't accidentally see scale as unchanged below
4216  scale = scale || ".5";
4217 
4218  // Adjust and apply
4219  initialInUnit = initialInUnit / scale;
4220  jQuery.style( elem, prop, initialInUnit + unit );
4221 
4222  // Update scale, tolerating zero or NaN from tween.cur()
4223  // Break the loop if scale is unchanged or perfect, or if we've just had enough.
4224  } while (
4225  scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
4226  );
4227  }
4228 
4229  if ( valueParts ) {
4230  initialInUnit = +initialInUnit || +initial || 0;
4231 
4232  // Apply relative offset (+=/-=) if specified
4233  adjusted = valueParts[ 1 ] ?
4234  initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4235  +valueParts[ 2 ];
4236  if ( tween ) {
4237  tween.unit = unit;
4238  tween.start = initialInUnit;
4239  tween.end = adjusted;
4240  }
4241  }
4242  return adjusted;
4243 }
4244 var rcheckableType = ( /^(?:checkbox|radio)$/i );
4245 
4246 var rtagName = ( /<([\w:-]+)/ );
4247 
4248 var rscriptType = ( /^$|\/(?:java|ecma)script/i );
4249 
4250 
4251 
4252 // We have to close these tags to support XHTML (#13200)
4253 var wrapMap = {
4254 
4255  // Support: IE9
4256  option: [ 1, "<select multiple='multiple'>", "</select>" ],
4257 
4258  // XHTML parsers do not magically insert elements in the
4259  // same way that tag soup parsers do. So we cannot shorten
4260  // this by omitting <tbody> or other required elements.
4261  thead: [ 1, "<table>", "</table>" ],
4262  col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
4263  tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4264  td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4265 
4266  _default: [ 0, "", "" ]
4267 };
4268 
4269 // Support: IE9
4270 wrapMap.optgroup = wrapMap.option;
4271 
4272 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4273 wrapMap.th = wrapMap.td;
4274 
4275 
4276 function getAll( context, tag ) {
4277 
4278  // Support: IE9-11+
4279  // Use typeof to avoid zero-argument method invocation on host objects (#15151)
4280  var ret = typeof context.getElementsByTagName !== "undefined" ?
4281  context.getElementsByTagName( tag || "*" ) :
4282  typeof context.querySelectorAll !== "undefined" ?
4283  context.querySelectorAll( tag || "*" ) :
4284  [];
4285 
4286  return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
4287  jQuery.merge( [ context ], ret ) :
4288  ret;
4289 }
4290 
4291 
4292 // Mark scripts as having already been evaluated
4293 function setGlobalEval( elems, refElements ) {
4294  var i = 0,
4295  l = elems.length;
4296 
4297  for ( ; i < l; i++ ) {
4298  dataPriv.set(
4299  elems[ i ],
4300  "globalEval",
4301  !refElements || dataPriv.get( refElements[ i ], "globalEval" )
4302  );
4303  }
4304 }
4305 
4306 
4307 var rhtml = /<|&#?\w+;/;
4308 
4309 function buildFragment( elems, context, scripts, selection, ignored ) {
4310  var elem, tmp, tag, wrap, contains, j,
4311  fragment = context.createDocumentFragment(),
4312  nodes = [],
4313  i = 0,
4314  l = elems.length;
4315 
4316  for ( ; i < l; i++ ) {
4317  elem = elems[ i ];
4318 
4319  if ( elem || elem === 0 ) {
4320 
4321  // Add nodes directly
4322  if ( jQuery.type( elem ) === "object" ) {
4323 
4324  // Support: Android<4.1, PhantomJS<2
4325  // push.apply(_, arraylike) throws on ancient WebKit
4326  jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
4327 
4328  // Convert non-html into a text node
4329  } else if ( !rhtml.test( elem ) ) {
4330  nodes.push( context.createTextNode( elem ) );
4331 
4332  // Convert html into DOM nodes
4333  } else {
4334  tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
4335 
4336  // Deserialize a standard representation
4337  tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
4338  wrap = wrapMap[ tag ] || wrapMap._default;
4339  tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
4340 
4341  // Descend through wrappers to the right content
4342  j = wrap[ 0 ];
4343  while ( j-- ) {
4344  tmp = tmp.lastChild;
4345  }
4346 
4347  // Support: Android<4.1, PhantomJS<2
4348  // push.apply(_, arraylike) throws on ancient WebKit
4349  jQuery.merge( nodes, tmp.childNodes );
4350 
4351  // Remember the top-level container
4352  tmp = fragment.firstChild;
4353 
4354  // Ensure the created nodes are orphaned (#12392)
4355  tmp.textContent = "";
4356  }
4357  }
4358  }
4359 
4360  // Remove wrapper from fragment
4361  fragment.textContent = "";
4362 
4363  i = 0;
4364  while ( ( elem = nodes[ i++ ] ) ) {
4365 
4366  // Skip elements already in the context collection (trac-4087)
4367  if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
4368  if ( ignored ) {
4369  ignored.push( elem );
4370  }
4371  continue;
4372  }
4373 
4374  contains = jQuery.contains( elem.ownerDocument, elem );
4375 
4376  // Append to fragment
4377  tmp = getAll( fragment.appendChild( elem ), "script" );
4378 
4379  // Preserve script evaluation history
4380  if ( contains ) {
4381  setGlobalEval( tmp );
4382  }
4383 
4384  // Capture executables
4385  if ( scripts ) {
4386  j = 0;
4387  while ( ( elem = tmp[ j++ ] ) ) {
4388  if ( rscriptType.test( elem.type || "" ) ) {
4389  scripts.push( elem );
4390  }
4391  }
4392  }
4393  }
4394 
4395  return fragment;
4396 }
4397 
4398 
4399 ( function() {
4400  var fragment = document.createDocumentFragment(),
4401  div = fragment.appendChild( document.createElement( "div" ) ),
4402  input = document.createElement( "input" );
4403 
4404  // Support: Android 4.0-4.3, Safari<=5.1
4405  // Check state lost if the name is set (#11217)
4406  // Support: Windows Web Apps (WWA)
4407  // `name` and `type` must use .setAttribute for WWA (#14901)
4408  input.setAttribute( "type", "radio" );
4409  input.setAttribute( "checked", "checked" );
4410  input.setAttribute( "name", "t" );
4411 
4412  div.appendChild( input );
4413 
4414  // Support: Safari<=5.1, Android<4.2
4415  // Older WebKit doesn't clone checked state correctly in fragments
4416  support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4417 
4418  // Support: IE<=11+
4419  // Make sure textarea (and checkbox) defaultValue is properly cloned
4420  div.innerHTML = "<textarea>x</textarea>";
4421  support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4422 } )();
4423 
4424 
4425 var
4426  rkeyEvent = /^key/,
4427  rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
4428  rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
4429 
4430 function returnTrue() {
4431  return true;
4432 }
4433 
4434 function returnFalse() {
4435  return false;
4436 }
4437 
4438 // Support: IE9
4439 // See #13393 for more info
4440 function safeActiveElement() {
4441  try {
4442  return document.activeElement;
4443  } catch ( err ) { }
4444 }
4445 
4446 function on( elem, types, selector, data, fn, one ) {
4447  var origFn, type;
4448 
4449  // Types can be a map of types/handlers
4450  if ( typeof types === "object" ) {
4451 
4452  // ( types-Object, selector, data )
4453  if ( typeof selector !== "string" ) {
4454 
4455  // ( types-Object, data )
4456  data = data || selector;
4457  selector = undefined;
4458  }
4459  for ( type in types ) {
4460  on( elem, type, selector, data, types[ type ], one );
4461  }
4462  return elem;
4463  }
4464 
4465  if ( data == null && fn == null ) {
4466 
4467  // ( types, fn )
4468  fn = selector;
4469  data = selector = undefined;
4470  } else if ( fn == null ) {
4471  if ( typeof selector === "string" ) {
4472 
4473  // ( types, selector, fn )
4474  fn = data;
4475  data = undefined;
4476  } else {
4477 
4478  // ( types, data, fn )
4479  fn = data;
4480  data = selector;
4481  selector = undefined;
4482  }
4483  }
4484  if ( fn === false ) {
4485  fn = returnFalse;
4486  } else if ( !fn ) {
4487  return elem;
4488  }
4489 
4490  if ( one === 1 ) {
4491  origFn = fn;
4492  fn = function( event ) {
4493 
4494  // Can use an empty set, since event contains the info
4495  jQuery().off( event );
4496  return origFn.apply( this, arguments );
4497  };
4498 
4499  // Use same guid so caller can remove using origFn
4500  fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
4501  }
4502  return elem.each( function() {
4503  jQuery.event.add( this, types, fn, data, selector );
4504  } );
4505 }
4506 
4507 /*
4508  * Helper functions for managing events -- not part of the public interface.
4509  * Props to Dean Edwards' addEvent library for many of the ideas.
4510  */
4511 jQuery.event = {
4512 
4513  global: {},
4514 
4515  add: function( elem, types, handler, data, selector ) {
4516 
4517  var handleObjIn, eventHandle, tmp,
4518  events, t, handleObj,
4519  special, handlers, type, namespaces, origType,
4520  elemData = dataPriv.get( elem );
4521 
4522  // Don't attach events to noData or text/comment nodes (but allow plain objects)
4523  if ( !elemData ) {
4524  return;
4525  }
4526 
4527  // Caller can pass in an object of custom data in lieu of the handler
4528  if ( handler.handler ) {
4529  handleObjIn = handler;
4530  handler = handleObjIn.handler;
4531  selector = handleObjIn.selector;
4532  }
4533 
4534  // Make sure that the handler has a unique ID, used to find/remove it later
4535  if ( !handler.guid ) {
4536  handler.guid = jQuery.guid++;
4537  }
4538 
4539  // Init the element's event structure and main handler, if this is the first
4540  if ( !( events = elemData.events ) ) {
4541  events = elemData.events = {};
4542  }
4543  if ( !( eventHandle = elemData.handle ) ) {
4544  eventHandle = elemData.handle = function( e ) {
4545 
4546  // Discard the second event of a jQuery.event.trigger() and
4547  // when an event is called after a page has unloaded
4548  return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
4549  jQuery.event.dispatch.apply( elem, arguments ) : undefined;
4550  };
4551  }
4552 
4553  // Handle multiple events separated by a space
4554  types = ( types || "" ).match( rnotwhite ) || [ "" ];
4555  t = types.length;
4556  while ( t-- ) {
4557  tmp = rtypenamespace.exec( types[ t ] ) || [];
4558  type = origType = tmp[ 1 ];
4559  namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
4560 
4561  // There *must* be a type, no attaching namespace-only handlers
4562  if ( !type ) {
4563  continue;
4564  }
4565 
4566  // If event changes its type, use the special event handlers for the changed type
4567  special = jQuery.event.special[ type ] || {};
4568 
4569  // If selector defined, determine special event api type, otherwise given type
4570  type = ( selector ? special.delegateType : special.bindType ) || type;
4571 
4572  // Update special based on newly reset type
4573  special = jQuery.event.special[ type ] || {};
4574 
4575  // handleObj is passed to all event handlers
4576  handleObj = jQuery.extend( {
4577  type: type,
4578  origType: origType,
4579  data: data,
4580  handler: handler,
4581  guid: handler.guid,
4582  selector: selector,
4583  needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
4584  namespace: namespaces.join( "." )
4585  }, handleObjIn );
4586 
4587  // Init the event handler queue if we're the first
4588  if ( !( handlers = events[ type ] ) ) {
4589  handlers = events[ type ] = [];
4590  handlers.delegateCount = 0;
4591 
4592  // Only use addEventListener if the special events handler returns false
4593  if ( !special.setup ||
4594  special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
4595 
4596  if ( elem.addEventListener ) {
4597  elem.addEventListener( type, eventHandle );
4598  }
4599  }
4600  }
4601 
4602  if ( special.add ) {
4603  special.add.call( elem, handleObj );
4604 
4605  if ( !handleObj.handler.guid ) {
4606  handleObj.handler.guid = handler.guid;
4607  }
4608  }
4609 
4610  // Add to the element's handler list, delegates in front
4611  if ( selector ) {
4612  handlers.splice( handlers.delegateCount++, 0, handleObj );
4613  } else {
4614  handlers.push( handleObj );
4615  }
4616 
4617  // Keep track of which events have ever been used, for event optimization
4618  jQuery.event.global[ type ] = true;
4619  }
4620 
4621  },
4622 
4623  // Detach an event or set of events from an element
4624  remove: function( elem, types, handler, selector, mappedTypes ) {
4625 
4626  var j, origCount, tmp,
4627  events, t, handleObj,
4628  special, handlers, type, namespaces, origType,
4629  elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
4630 
4631  if ( !elemData || !( events = elemData.events ) ) {
4632  return;
4633  }
4634 
4635  // Once for each type.namespace in types; type may be omitted
4636  types = ( types || "" ).match( rnotwhite ) || [ "" ];
4637  t = types.length;
4638  while ( t-- ) {
4639  tmp = rtypenamespace.exec( types[ t ] ) || [];
4640  type = origType = tmp[ 1 ];
4641  namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
4642 
4643  // Unbind all events (on this namespace, if provided) for the element
4644  if ( !type ) {
4645  for ( type in events ) {
4646  jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
4647  }
4648  continue;
4649  }
4650 
4651  special = jQuery.event.special[ type ] || {};
4652  type = ( selector ? special.delegateType : special.bindType ) || type;
4653  handlers = events[ type ] || [];
4654  tmp = tmp[ 2 ] &&
4655  new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
4656 
4657  // Remove matching events
4658  origCount = j = handlers.length;
4659  while ( j-- ) {
4660  handleObj = handlers[ j ];
4661 
4662  if ( ( mappedTypes || origType === handleObj.origType ) &&
4663  ( !handler || handler.guid === handleObj.guid ) &&
4664  ( !tmp || tmp.test( handleObj.namespace ) ) &&
4665  ( !selector || selector === handleObj.selector ||
4666  selector === "**" && handleObj.selector ) ) {
4667  handlers.splice( j, 1 );
4668 
4669  if ( handleObj.selector ) {
4670  handlers.delegateCount--;
4671  }
4672  if ( special.remove ) {
4673  special.remove.call( elem, handleObj );
4674  }
4675  }
4676  }
4677 
4678  // Remove generic event handler if we removed something and no more handlers exist
4679  // (avoids potential for endless recursion during removal of special event handlers)
4680  if ( origCount && !handlers.length ) {
4681  if ( !special.teardown ||
4682  special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
4683 
4684  jQuery.removeEvent( elem, type, elemData.handle );
4685  }
4686 
4687  delete events[ type ];
4688  }
4689  }
4690 
4691  // Remove data and the expando if it's no longer used
4692  if ( jQuery.isEmptyObject( events ) ) {
4693  dataPriv.remove( elem, "handle events" );
4694  }
4695  },
4696 
4697  dispatch: function( event ) {
4698 
4699  // Make a writable jQuery.Event from the native event object
4700  event = jQuery.event.fix( event );
4701 
4702  var i, j, ret, matched, handleObj,
4703  handlerQueue = [],
4704  args = slice.call( arguments ),
4705  handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
4706  special = jQuery.event.special[ event.type ] || {};
4707 
4708  // Use the fix-ed jQuery.Event rather than the (read-only) native event
4709  args[ 0 ] = event;
4710  event.delegateTarget = this;
4711 
4712  // Call the preDispatch hook for the mapped type, and let it bail if desired
4713  if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
4714  return;
4715  }
4716 
4717  // Determine handlers
4718  handlerQueue = jQuery.event.handlers.call( this, event, handlers );
4719 
4720  // Run delegates first; they may want to stop propagation beneath us
4721  i = 0;
4722  while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
4723  event.currentTarget = matched.elem;
4724 
4725  j = 0;
4726  while ( ( handleObj = matched.handlers[ j++ ] ) &&
4727  !event.isImmediatePropagationStopped() ) {
4728 
4729  // Triggered event must either 1) have no namespace, or 2) have namespace(s)
4730  // a subset or equal to those in the bound event (both can have no namespace).
4731  if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
4732 
4733  event.handleObj = handleObj;
4734  event.data = handleObj.data;
4735 
4736  ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
4737  handleObj.handler ).apply( matched.elem, args );
4738 
4739  if ( ret !== undefined ) {
4740  if ( ( event.result = ret ) === false ) {
4741  event.preventDefault();
4742  event.stopPropagation();
4743  }
4744  }
4745  }
4746  }
4747  }
4748 
4749  // Call the postDispatch hook for the mapped type
4750  if ( special.postDispatch ) {
4751  special.postDispatch.call( this, event );
4752  }
4753 
4754  return event.result;
4755  },
4756 
4757  handlers: function( event, handlers ) {
4758  var i, matches, sel, handleObj,
4759  handlerQueue = [],
4760  delegateCount = handlers.delegateCount,
4761  cur = event.target;
4762 
4763  // Support (at least): Chrome, IE9
4764  // Find delegate handlers
4765  // Black-hole SVG <use> instance trees (#13180)
4766  //
4767  // Support: Firefox<=42+
4768  // Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
4769  if ( delegateCount && cur.nodeType &&
4770  ( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
4771 
4772  for ( ; cur !== this; cur = cur.parentNode || this ) {
4773 
4774  // Don't check non-elements (#13208)
4775  // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
4776  if ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== "click" ) ) {
4777  matches = [];
4778  for ( i = 0; i < delegateCount; i++ ) {
4779  handleObj = handlers[ i ];
4780 
4781  // Don't conflict with Object.prototype properties (#13203)
4782  sel = handleObj.selector + " ";
4783 
4784  if ( matches[ sel ] === undefined ) {
4785  matches[ sel ] = handleObj.needsContext ?
4786  jQuery( sel, this ).index( cur ) > -1 :
4787  jQuery.find( sel, this, null, [ cur ] ).length;
4788  }
4789  if ( matches[ sel ] ) {
4790  matches.push( handleObj );
4791  }
4792  }
4793  if ( matches.length ) {
4794  handlerQueue.push( { elem: cur, handlers: matches } );
4795  }
4796  }
4797  }
4798  }
4799 
4800  // Add the remaining (directly-bound) handlers
4801  if ( delegateCount < handlers.length ) {
4802  handlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );
4803  }
4804 
4805  return handlerQueue;
4806  },
4807 
4808  // Includes some event props shared by KeyEvent and MouseEvent
4809  props: ( "altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " +
4810  "metaKey relatedTarget shiftKey target timeStamp view which" ).split( " " ),
4811 
4812  fixHooks: {},
4813 
4814  keyHooks: {
4815  props: "char charCode key keyCode".split( " " ),
4816  filter: function( event, original ) {
4817 
4818  // Add which for key events
4819  if ( event.which == null ) {
4820  event.which = original.charCode != null ? original.charCode : original.keyCode;
4821  }
4822 
4823  return event;
4824  }
4825  },
4826 
4827  mouseHooks: {
4828  props: ( "button buttons clientX clientY offsetX offsetY pageX pageY " +
4829  "screenX screenY toElement" ).split( " " ),
4830  filter: function( event, original ) {
4831  var eventDoc, doc, body,
4832  button = original.button;
4833 
4834  // Calculate pageX/Y if missing and clientX/Y available
4835  if ( event.pageX == null && original.clientX != null ) {
4836  eventDoc = event.target.ownerDocument || document;
4837  doc = eventDoc.documentElement;
4838  body = eventDoc.body;
4839 
4840  event.pageX = original.clientX +
4841  ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
4842  ( doc && doc.clientLeft || body && body.clientLeft || 0 );
4843  event.pageY = original.clientY +
4844  ( doc && doc.scrollTop || body && body.scrollTop || 0 ) -
4845  ( doc && doc.clientTop || body && body.clientTop || 0 );
4846  }
4847 
4848  // Add which for click: 1 === left; 2 === middle; 3 === right
4849  // Note: button is not normalized, so don't use it
4850  if ( !event.which && button !== undefined ) {
4851  event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
4852  }
4853 
4854  return event;
4855  }
4856  },
4857 
4858  fix: function( event ) {
4859  if ( event[ jQuery.expando ] ) {
4860  return event;
4861  }
4862 
4863  // Create a writable copy of the event object and normalize some properties
4864  var i, prop, copy,
4865  type = event.type,
4866  originalEvent = event,
4867  fixHook = this.fixHooks[ type ];
4868 
4869  if ( !fixHook ) {
4870  this.fixHooks[ type ] = fixHook =
4871  rmouseEvent.test( type ) ? this.mouseHooks :
4872  rkeyEvent.test( type ) ? this.keyHooks :
4873  {};
4874  }
4875  copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
4876 
4877  event = new jQuery.Event( originalEvent );
4878 
4879  i = copy.length;
4880  while ( i-- ) {
4881  prop = copy[ i ];
4882  event[ prop ] = originalEvent[ prop ];
4883  }
4884 
4885  // Support: Cordova 2.5 (WebKit) (#13255)
4886  // All events should have a target; Cordova deviceready doesn't
4887  if ( !event.target ) {
4888  event.target = document;
4889  }
4890 
4891  // Support: Safari 6.0+, Chrome<28
4892  // Target should not be a text node (#504, #13143)
4893  if ( event.target.nodeType === 3 ) {
4894  event.target = event.target.parentNode;
4895  }
4896 
4897  return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
4898  },
4899 
4900  special: {
4901  load: {
4902 
4903  // Prevent triggered image.load events from bubbling to window.load
4904  noBubble: true
4905  },
4906  focus: {
4907 
4908  // Fire native event if possible so blur/focus sequence is correct
4909  trigger: function() {
4910  if ( this !== safeActiveElement() && this.focus ) {
4911  this.focus();
4912  return false;
4913  }
4914  },
4915  delegateType: "focusin"
4916  },
4917  blur: {
4918  trigger: function() {
4919  if ( this === safeActiveElement() && this.blur ) {
4920  this.blur();
4921  return false;
4922  }
4923  },
4924  delegateType: "focusout"
4925  },
4926  click: {
4927 
4928  // For checkbox, fire native event so checked state will be right
4929  trigger: function() {
4930  if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
4931  this.click();
4932  return false;
4933  }
4934  },
4935 
4936  // For cross-browser consistency, don't fire native .click() on links
4937  _default: function( event ) {
4938  return jQuery.nodeName( event.target, "a" );
4939  }
4940  },
4941 
4942  beforeunload: {
4943  postDispatch: function( event ) {
4944 
4945  // Support: Firefox 20+
4946  // Firefox doesn't alert if the returnValue field is not set.
4947  if ( event.result !== undefined && event.originalEvent ) {
4948  event.originalEvent.returnValue = event.result;
4949  }
4950  }
4951  }
4952  }
4953 };
4954 
4955 jQuery.removeEvent = function( elem, type, handle ) {
4956 
4957  // This "if" is needed for plain objects
4958  if ( elem.removeEventListener ) {
4959  elem.removeEventListener( type, handle );
4960  }
4961 };
4962 
4963 jQuery.Event = function( src, props ) {
4964 
4965  // Allow instantiation without the 'new' keyword
4966  if ( !( this instanceof jQuery.Event ) ) {
4967  return new jQuery.Event( src, props );
4968  }
4969 
4970  // Event object
4971  if ( src && src.type ) {
4972  this.originalEvent = src;
4973  this.type = src.type;
4974 
4975  // Events bubbling up the document may have been marked as prevented
4976  // by a handler lower down the tree; reflect the correct value.
4977  this.isDefaultPrevented = src.defaultPrevented ||
4978  src.defaultPrevented === undefined &&
4979 
4980  // Support: Android<4.0
4981  src.returnValue === false ?
4982  returnTrue :
4983  returnFalse;
4984 
4985  // Event type
4986  } else {
4987  this.type = src;
4988  }
4989 
4990  // Put explicitly provided properties onto the event object
4991  if ( props ) {
4992  jQuery.extend( this, props );
4993  }
4994 
4995  // Create a timestamp if incoming event doesn't have one
4996  this.timeStamp = src && src.timeStamp || jQuery.now();
4997 
4998  // Mark it as fixed
4999  this[ jQuery.expando ] = true;
5000 };
5001 
5002 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5003 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5004 jQuery.Event.prototype = {
5005  constructor: jQuery.Event,
5006  isDefaultPrevented: returnFalse,
5007  isPropagationStopped: returnFalse,
5008  isImmediatePropagationStopped: returnFalse,
5009  isSimulated: false,
5010 
5011  preventDefault: function() {
5012  var e = this.originalEvent;
5013 
5014  this.isDefaultPrevented = returnTrue;
5015 
5016  if ( e && !this.isSimulated ) {
5017  e.preventDefault();
5018  }
5019  },
5020  stopPropagation: function() {
5021  var e = this.originalEvent;
5022 
5023  this.isPropagationStopped = returnTrue;
5024 
5025  if ( e && !this.isSimulated ) {
5026  e.stopPropagation();
5027  }
5028  },
5029  stopImmediatePropagation: function() {
5030  var e = this.originalEvent;
5031 
5032  this.isImmediatePropagationStopped = returnTrue;
5033 
5034  if ( e && !this.isSimulated ) {
5035  e.stopImmediatePropagation();
5036  }
5037 
5038  this.stopPropagation();
5039  }
5040 };
5041 
5042 // Create mouseenter/leave events using mouseover/out and event-time checks
5043 // so that event delegation works in jQuery.
5044 // Do the same for pointerenter/pointerleave and pointerover/pointerout
5045 //
5046 // Support: Safari 7 only
5047 // Safari sends mouseenter too often; see:
5048 // https://code.google.com/p/chromium/issues/detail?id=470258
5049 // for the description of the bug (it existed in older Chrome versions as well).
5050 jQuery.each( {
5051  mouseenter: "mouseover",
5052  mouseleave: "mouseout",
5053  pointerenter: "pointerover",
5054  pointerleave: "pointerout"
5055 }, function( orig, fix ) {
5056  jQuery.event.special[ orig ] = {
5057  delegateType: fix,
5058  bindType: fix,
5059 
5060  handle: function( event ) {
5061  var ret,
5062  target = this,
5063  related = event.relatedTarget,
5064  handleObj = event.handleObj;
5065 
5066  // For mouseenter/leave call the handler if related is outside the target.
5067  // NB: No relatedTarget if the mouse left/entered the browser window
5068  if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5069  event.type = handleObj.origType;
5070  ret = handleObj.handler.apply( this, arguments );
5071  event.type = fix;
5072  }
5073  return ret;
5074  }
5075  };
5076 } );
5077 
5078 jQuery.fn.extend( {
5079  on: function( types, selector, data, fn ) {
5080  return on( this, types, selector, data, fn );
5081  },
5082  one: function( types, selector, data, fn ) {
5083  return on( this, types, selector, data, fn, 1 );
5084  },
5085  off: function( types, selector, fn ) {
5086  var handleObj, type;
5087  if ( types && types.preventDefault && types.handleObj ) {
5088 
5089  // ( event ) dispatched jQuery.Event
5090  handleObj = types.handleObj;
5091  jQuery( types.delegateTarget ).off(
5092  handleObj.namespace ?
5093  handleObj.origType + "." + handleObj.namespace :
5094  handleObj.origType,
5095  handleObj.selector,
5096  handleObj.handler
5097  );
5098  return this;
5099  }
5100  if ( typeof types === "object" ) {
5101 
5102  // ( types-object [, selector] )
5103  for ( type in types ) {
5104  this.off( type, selector, types[ type ] );
5105  }
5106  return this;
5107  }
5108  if ( selector === false || typeof selector === "function" ) {
5109 
5110  // ( types [, fn] )
5111  fn = selector;
5112  selector = undefined;
5113  }
5114  if ( fn === false ) {
5115  fn = returnFalse;
5116  }
5117  return this.each( function() {
5118  jQuery.event.remove( this, types, fn, selector );
5119  } );
5120  }
5121 } );
5122 
5123 
5124 var
5125  rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
5126 
5127  // Support: IE 10-11, Edge 10240+
5128  // In IE/Edge using regex groups here causes severe slowdowns.
5129  // See https://connect.microsoft.com/IE/feedback/details/1736512/
5130  rnoInnerhtml = /<script|<style|<link/i,
5131 
5132  // checked="checked" or checked
5133  rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5134  rscriptTypeMasked = /^true\/(.*)/,
5135  rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
5136 
5137 // Manipulating tables requires a tbody
5138 function manipulationTarget( elem, content ) {
5139  return jQuery.nodeName( elem, "table" ) &&
5140  jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
5141 
5142  elem.getElementsByTagName( "tbody" )[ 0 ] ||
5143  elem.appendChild( elem.ownerDocument.createElement( "tbody" ) ) :
5144  elem;
5145 }
5146 
5147 // Replace/restore the type attribute of script elements for safe DOM manipulation
5148 function disableScript( elem ) {
5149  elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
5150  return elem;
5151 }
5152 function restoreScript( elem ) {
5153  var match = rscriptTypeMasked.exec( elem.type );
5154 
5155  if ( match ) {
5156  elem.type = match[ 1 ];
5157  } else {
5158  elem.removeAttribute( "type" );
5159  }
5160 
5161  return elem;
5162 }
5163 
5164 function cloneCopyEvent( src, dest ) {
5165  var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
5166 
5167  if ( dest.nodeType !== 1 ) {
5168  return;
5169  }
5170 
5171  // 1. Copy private data: events, handlers, etc.
5172  if ( dataPriv.hasData( src ) ) {
5173  pdataOld = dataPriv.access( src );
5174  pdataCur = dataPriv.set( dest, pdataOld );
5175  events = pdataOld.events;
5176 
5177  if ( events ) {
5178  delete pdataCur.handle;
5179  pdataCur.events = {};
5180 
5181  for ( type in events ) {
5182  for ( i = 0, l = events[ type ].length; i < l; i++ ) {
5183  jQuery.event.add( dest, type, events[ type ][ i ] );
5184  }
5185  }
5186  }
5187  }
5188 
5189  // 2. Copy user data
5190  if ( dataUser.hasData( src ) ) {
5191  udataOld = dataUser.access( src );
5192  udataCur = jQuery.extend( {}, udataOld );
5193 
5194  dataUser.set( dest, udataCur );
5195  }
5196 }
5197 
5198 // Fix IE bugs, see support tests
5199 function fixInput( src, dest ) {
5200  var nodeName = dest.nodeName.toLowerCase();
5201 
5202  // Fails to persist the checked state of a cloned checkbox or radio button.
5203  if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
5204  dest.checked = src.checked;
5205 
5206  // Fails to return the selected option to the default selected state when cloning options
5207  } else if ( nodeName === "input" || nodeName === "textarea" ) {
5208  dest.defaultValue = src.defaultValue;
5209  }
5210 }
5211 
5212 function domManip( collection, args, callback, ignored ) {
5213 
5214  // Flatten any nested arrays
5215  args = concat.apply( [], args );
5216 
5217  var fragment, first, scripts, hasScripts, node, doc,
5218  i = 0,
5219  l = collection.length,
5220  iNoClone = l - 1,
5221  value = args[ 0 ],
5222  isFunction = jQuery.isFunction( value );
5223 
5224  // We can't cloneNode fragments that contain checked, in WebKit
5225  if ( isFunction ||
5226  ( l > 1 && typeof value === "string" &&
5227  !support.checkClone && rchecked.test( value ) ) ) {
5228  return collection.each( function( index ) {
5229  var self = collection.eq( index );
5230  if ( isFunction ) {
5231  args[ 0 ] = value.call( this, index, self.html() );
5232  }
5233  domManip( self, args, callback, ignored );
5234  } );
5235  }
5236 
5237  if ( l ) {
5238  fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
5239  first = fragment.firstChild;
5240 
5241  if ( fragment.childNodes.length === 1 ) {
5242  fragment = first;
5243  }
5244 
5245  // Require either new content or an interest in ignored elements to invoke the callback
5246  if ( first || ignored ) {
5247  scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
5248  hasScripts = scripts.length;
5249 
5250  // Use the original fragment for the last item
5251  // instead of the first because it can end up
5252  // being emptied incorrectly in certain situations (#8070).
5253  for ( ; i < l; i++ ) {
5254  node = fragment;
5255 
5256  if ( i !== iNoClone ) {
5257  node = jQuery.clone( node, true, true );
5258 
5259  // Keep references to cloned scripts for later restoration
5260  if ( hasScripts ) {
5261 
5262  // Support: Android<4.1, PhantomJS<2
5263  // push.apply(_, arraylike) throws on ancient WebKit
5264  jQuery.merge( scripts, getAll( node, "script" ) );
5265  }
5266  }
5267 
5268  callback.call( collection[ i ], node, i );
5269  }
5270 
5271  if ( hasScripts ) {
5272  doc = scripts[ scripts.length - 1 ].ownerDocument;
5273 
5274  // Reenable scripts
5275  jQuery.map( scripts, restoreScript );
5276 
5277  // Evaluate executable scripts on first document insertion
5278  for ( i = 0; i < hasScripts; i++ ) {
5279  node = scripts[ i ];
5280  if ( rscriptType.test( node.type || "" ) &&
5281  !dataPriv.access( node, "globalEval" ) &&
5282  jQuery.contains( doc, node ) ) {
5283 
5284  if ( node.src ) {
5285 
5286  // Optional AJAX dependency, but won't run scripts if not present
5287  if ( jQuery._evalUrl ) {
5288  jQuery._evalUrl( node.src );
5289  }
5290  } else {
5291  jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
5292  }
5293  }
5294  }
5295  }
5296  }
5297  }
5298 
5299  return collection;
5300 }
5301 
5302 function remove( elem, selector, keepData ) {
5303  var node,
5304  nodes = selector ? jQuery.filter( selector, elem ) : elem,
5305  i = 0;
5306 
5307  for ( ; ( node = nodes[ i ] ) != null; i++ ) {
5308  if ( !keepData && node.nodeType === 1 ) {
5309  jQuery.cleanData( getAll( node ) );
5310  }
5311 
5312  if ( node.parentNode ) {
5313  if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
5314  setGlobalEval( getAll( node, "script" ) );
5315  }
5316  node.parentNode.removeChild( node );
5317  }
5318  }
5319 
5320  return elem;
5321 }
5322 
5323 jQuery.extend( {
5324  htmlPrefilter: function( html ) {
5325  return html.replace( rxhtmlTag, "<$1></$2>" );
5326  },
5327 
5328  clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5329  var i, l, srcElements, destElements,
5330  clone = elem.cloneNode( true ),
5331  inPage = jQuery.contains( elem.ownerDocument, elem );
5332 
5333  // Fix IE cloning issues
5334  if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
5335  !jQuery.isXMLDoc( elem ) ) {
5336 
5337  // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
5338  destElements = getAll( clone );
5339  srcElements = getAll( elem );
5340 
5341  for ( i = 0, l = srcElements.length; i < l; i++ ) {
5342  fixInput( srcElements[ i ], destElements[ i ] );
5343  }
5344  }
5345 
5346  // Copy the events from the original to the clone
5347  if ( dataAndEvents ) {
5348  if ( deepDataAndEvents ) {
5349  srcElements = srcElements || getAll( elem );
5350  destElements = destElements || getAll( clone );
5351 
5352  for ( i = 0, l = srcElements.length; i < l; i++ ) {
5353  cloneCopyEvent( srcElements[ i ], destElements[ i ] );
5354  }
5355  } else {
5356  cloneCopyEvent( elem, clone );
5357  }
5358  }
5359 
5360  // Preserve script evaluation history
5361  destElements = getAll( clone, "script" );
5362  if ( destElements.length > 0 ) {
5363  setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
5364  }
5365 
5366  // Return the cloned set
5367  return clone;
5368  },
5369 
5370  cleanData: function( elems ) {
5371  var data, elem, type,
5372  special = jQuery.event.special,
5373  i = 0;
5374 
5375  for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
5376  if ( acceptData( elem ) ) {
5377  if ( ( data = elem[ dataPriv.expando ] ) ) {
5378  if ( data.events ) {
5379  for ( type in data.events ) {
5380  if ( special[ type ] ) {
5381  jQuery.event.remove( elem, type );
5382 
5383  // This is a shortcut to avoid jQuery.event.remove's overhead
5384  } else {
5385  jQuery.removeEvent( elem, type, data.handle );
5386  }
5387  }
5388  }
5389 
5390  // Support: Chrome <= 35-45+
5391  // Assign undefined instead of using delete, see Data#remove
5392  elem[ dataPriv.expando ] = undefined;
5393  }
5394  if ( elem[ dataUser.expando ] ) {
5395 
5396  // Support: Chrome <= 35-45+
5397  // Assign undefined instead of using delete, see Data#remove
5398  elem[ dataUser.expando ] = undefined;
5399  }
5400  }
5401  }
5402  }
5403 } );
5404 
5405 jQuery.fn.extend( {
5406 
5407  // Keep domManip exposed until 3.0 (gh-2225)
5408  domManip: domManip,
5409 
5410  detach: function( selector ) {
5411  return remove( this, selector, true );
5412  },
5413 
5414  remove: function( selector ) {
5415  return remove( this, selector );
5416  },
5417 
5418  text: function( value ) {
5419  return access( this, function( value ) {
5420  return value === undefined ?
5421  jQuery.text( this ) :
5422  this.empty().each( function() {
5423  if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5424  this.textContent = value;
5425  }
5426  } );
5427  }, null, value, arguments.length );
5428  },
5429 
5430  append: function() {
5431  return domManip( this, arguments, function( elem ) {
5432  if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5433  var target = manipulationTarget( this, elem );
5434  target.appendChild( elem );
5435  }
5436  } );
5437  },
5438 
5439  prepend: function() {
5440  return domManip( this, arguments, function( elem ) {
5441  if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5442  var target = manipulationTarget( this, elem );
5443  target.insertBefore( elem, target.firstChild );
5444  }
5445  } );
5446  },
5447 
5448  before: function() {
5449  return domManip( this, arguments, function( elem ) {
5450  if ( this.parentNode ) {
5451  this.parentNode.insertBefore( elem, this );
5452  }
5453  } );
5454  },
5455 
5456  after: function() {
5457  return domManip( this, arguments, function( elem ) {
5458  if ( this.parentNode ) {
5459  this.parentNode.insertBefore( elem, this.nextSibling );
5460  }
5461  } );
5462  },
5463 
5464  empty: function() {
5465  var elem,
5466  i = 0;
5467 
5468  for ( ; ( elem = this[ i ] ) != null; i++ ) {
5469  if ( elem.nodeType === 1 ) {
5470 
5471  // Prevent memory leaks
5472  jQuery.cleanData( getAll( elem, false ) );
5473 
5474  // Remove any remaining nodes
5475  elem.textContent = "";
5476  }
5477  }
5478 
5479  return this;
5480  },
5481 
5482  clone: function( dataAndEvents, deepDataAndEvents ) {
5483  dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5484  deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5485 
5486  return this.map( function() {
5487  return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5488  } );
5489  },
5490 
5491  html: function( value ) {
5492  return access( this, function( value ) {
5493  var elem = this[ 0 ] || {},
5494  i = 0,
5495  l = this.length;
5496 
5497  if ( value === undefined && elem.nodeType === 1 ) {
5498  return elem.innerHTML;
5499  }
5500 
5501  // See if we can take a shortcut and just use innerHTML
5502  if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
5503  !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
5504 
5505  value = jQuery.htmlPrefilter( value );
5506 
5507  try {
5508  for ( ; i < l; i++ ) {
5509  elem = this[ i ] || {};
5510 
5511  // Remove element nodes and prevent memory leaks
5512  if ( elem.nodeType === 1 ) {
5513  jQuery.cleanData( getAll( elem, false ) );
5514  elem.innerHTML = value;
5515  }
5516  }
5517 
5518  elem = 0;
5519 
5520  // If using innerHTML throws an exception, use the fallback method
5521  } catch ( e ) {}
5522  }
5523 
5524  if ( elem ) {
5525  this.empty().append( value );
5526  }
5527  }, null, value, arguments.length );
5528  },
5529 
5530  replaceWith: function() {
5531  var ignored = [];
5532 
5533  // Make the changes, replacing each non-ignored context element with the new content
5534  return domManip( this, arguments, function( elem ) {
5535  var parent = this.parentNode;
5536 
5537  if ( jQuery.inArray( this, ignored ) < 0 ) {
5538  jQuery.cleanData( getAll( this ) );
5539  if ( parent ) {
5540  parent.replaceChild( elem, this );
5541  }
5542  }
5543 
5544  // Force callback invocation
5545  }, ignored );
5546  }
5547 } );
5548 
5549 jQuery.each( {
5550  appendTo: "append",
5551  prependTo: "prepend",
5552  insertBefore: "before",
5553  insertAfter: "after",
5554  replaceAll: "replaceWith"
5555 }, function( name, original ) {
5556  jQuery.fn[ name ] = function( selector ) {
5557  var elems,
5558  ret = [],
5559  insert = jQuery( selector ),
5560  last = insert.length - 1,
5561  i = 0;
5562 
5563  for ( ; i <= last; i++ ) {
5564  elems = i === last ? this : this.clone( true );
5565  jQuery( insert[ i ] )[ original ]( elems );
5566 
5567  // Support: QtWebKit
5568  // .get() because push.apply(_, arraylike) throws
5569  push.apply( ret, elems.get() );
5570  }
5571 
5572  return this.pushStack( ret );
5573  };
5574 } );
5575 
5576 
5577 var iframe,
5578  elemdisplay = {
5579 
5580  // Support: Firefox
5581  // We have to pre-define these values for FF (#10227)
5582  HTML: "block",
5583  BODY: "block"
5584  };
5585 
5592 // Called only from within defaultDisplay
5593 function actualDisplay( name, doc ) {
5594  var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
5595 
5596  display = jQuery.css( elem[ 0 ], "display" );
5597 
5598  // We don't have any data stored on the element,
5599  // so use "detach" method as fast way to get rid of the element
5600  elem.detach();
5601 
5602  return display;
5603 }
5604 
5609 function defaultDisplay( nodeName ) {
5610  var doc = document,
5611  display = elemdisplay[ nodeName ];
5612 
5613  if ( !display ) {
5614  display = actualDisplay( nodeName, doc );
5615 
5616  // If the simple way fails, read from inside an iframe
5617  if ( display === "none" || !display ) {
5618 
5619  // Use the already-created iframe if possible
5620  iframe = ( iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" ) )
5621  .appendTo( doc.documentElement );
5622 
5623  // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
5624  doc = iframe[ 0 ].contentDocument;
5625 
5626  // Support: IE
5627  doc.write();
5628  doc.close();
5629 
5630  display = actualDisplay( nodeName, doc );
5631  iframe.detach();
5632  }
5633 
5634  // Store the correct default display
5635  elemdisplay[ nodeName ] = display;
5636  }
5637 
5638  return display;
5639 }
5640 var rmargin = ( /^margin/ );
5641 
5642 var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
5643 
5644 var getStyles = function( elem ) {
5645 
5646  // Support: IE<=11+, Firefox<=30+ (#15098, #14150)
5647  // IE throws on elements created in popups
5648  // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
5649  var view = elem.ownerDocument.defaultView;
5650 
5651  if ( !view || !view.opener ) {
5652  view = window;
5653  }
5654 
5655  return view.getComputedStyle( elem );
5656  };
5657 
5658 var swap = function( elem, options, callback, args ) {
5659  var ret, name,
5660  old = {};
5661 
5662  // Remember the old values, and insert the new ones
5663  for ( name in options ) {
5664  old[ name ] = elem.style[ name ];
5665  elem.style[ name ] = options[ name ];
5666  }
5667 
5668  ret = callback.apply( elem, args || [] );
5669 
5670  // Revert the old values
5671  for ( name in options ) {
5672  elem.style[ name ] = old[ name ];
5673  }
5674 
5675  return ret;
5676 };
5677 
5678 
5679 var documentElement = document.documentElement;
5680 
5681 
5682 
5683 ( function() {
5684  var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
5685  container = document.createElement( "div" ),
5686  div = document.createElement( "div" );
5687 
5688  // Finish early in limited (non-browser) environments
5689  if ( !div.style ) {
5690  return;
5691  }
5692 
5693  // Support: IE9-11+
5694  // Style of cloned element affects source element cloned (#8908)
5695  div.style.backgroundClip = "content-box";
5696  div.cloneNode( true ).style.backgroundClip = "";
5697  support.clearCloneStyle = div.style.backgroundClip === "content-box";
5698 
5699  container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
5700  "padding:0;margin-top:1px;position:absolute";
5701  container.appendChild( div );
5702 
5703  // Executing both pixelPosition & boxSizingReliable tests require only one layout
5704  // so they're executed at the same time to save the second computation.
5705  function computeStyleTests() {
5706  div.style.cssText =
5707 
5708  // Support: Firefox<29, Android 2.3
5709  // Vendor-prefix box-sizing
5710  "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;" +
5711  "position:relative;display:block;" +
5712  "margin:auto;border:1px;padding:1px;" +
5713  "top:1%;width:50%";
5714  div.innerHTML = "";
5715  documentElement.appendChild( container );
5716 
5717  var divStyle = window.getComputedStyle( div );
5718  pixelPositionVal = divStyle.top !== "1%";
5719  reliableMarginLeftVal = divStyle.marginLeft === "2px";
5720  boxSizingReliableVal = divStyle.width === "4px";
5721 
5722  // Support: Android 4.0 - 4.3 only
5723  // Some styles come back with percentage values, even though they shouldn't
5724  div.style.marginRight = "50%";
5725  pixelMarginRightVal = divStyle.marginRight === "4px";
5726 
5727  documentElement.removeChild( container );
5728  }
5729 
5730  jQuery.extend( support, {
5731  pixelPosition: function() {
5732 
5733  // This test is executed only once but we still do memoizing
5734  // since we can use the boxSizingReliable pre-computing.
5735  // No need to check if the test was already performed, though.
5736  computeStyleTests();
5737  return pixelPositionVal;
5738  },
5739  boxSizingReliable: function() {
5740  if ( boxSizingReliableVal == null ) {
5741  computeStyleTests();
5742  }
5743  return boxSizingReliableVal;
5744  },
5745  pixelMarginRight: function() {
5746 
5747  // Support: Android 4.0-4.3
5748  // We're checking for boxSizingReliableVal here instead of pixelMarginRightVal
5749  // since that compresses better and they're computed together anyway.
5750  if ( boxSizingReliableVal == null ) {
5751  computeStyleTests();
5752  }
5753  return pixelMarginRightVal;
5754  },
5755  reliableMarginLeft: function() {
5756 
5757  // Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
5758  if ( boxSizingReliableVal == null ) {
5759  computeStyleTests();
5760  }
5761  return reliableMarginLeftVal;
5762  },
5763  reliableMarginRight: function() {
5764 
5765  // Support: Android 2.3
5766  // Check if div with explicit width and no margin-right incorrectly
5767  // gets computed margin-right based on width of container. (#3333)
5768  // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
5769  // This support function is only executed once so no memoizing is needed.
5770  var ret,
5771  marginDiv = div.appendChild( document.createElement( "div" ) );
5772 
5773  // Reset CSS: box-sizing; display; margin; border; padding
5774  marginDiv.style.cssText = div.style.cssText =
5775 
5776  // Support: Android 2.3
5777  // Vendor-prefix box-sizing
5778  "-webkit-box-sizing:content-box;box-sizing:content-box;" +
5779  "display:block;margin:0;border:0;padding:0";
5780  marginDiv.style.marginRight = marginDiv.style.width = "0";
5781  div.style.width = "1px";
5782  documentElement.appendChild( container );
5783 
5784  ret = !parseFloat( window.getComputedStyle( marginDiv ).marginRight );
5785 
5786  documentElement.removeChild( container );
5787  div.removeChild( marginDiv );
5788 
5789  return ret;
5790  }
5791  } );
5792 } )();
5793 
5794 
5795 function curCSS( elem, name, computed ) {
5796  var width, minWidth, maxWidth, ret,
5797  style = elem.style;
5798 
5799  computed = computed || getStyles( elem );
5800  ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;
5801 
5802  // Support: Opera 12.1x only
5803  // Fall back to style even without computed
5804  // computed is undefined for elems on document fragments
5805  if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {
5806  ret = jQuery.style( elem, name );
5807  }
5808 
5809  // Support: IE9
5810  // getPropertyValue is only needed for .css('filter') (#12537)
5811  if ( computed ) {
5812 
5813  // A tribute to the "awesome hack by Dean Edwards"
5814  // Android Browser returns percentage for some values,
5815  // but width seems to be reliably pixels.
5816  // This is against the CSSOM draft spec:
5817  // http://dev.w3.org/csswg/cssom/#resolved-values
5818  if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
5819 
5820  // Remember the original values
5821  width = style.width;
5822  minWidth = style.minWidth;
5823  maxWidth = style.maxWidth;
5824 
5825  // Put in the new values to get a computed value out
5826  style.minWidth = style.maxWidth = style.width = ret;
5827  ret = computed.width;
5828 
5829  // Revert the changed values
5830  style.width = width;
5831  style.minWidth = minWidth;
5832  style.maxWidth = maxWidth;
5833  }
5834  }
5835 
5836  return ret !== undefined ?
5837 
5838  // Support: IE9-11+
5839  // IE returns zIndex value as an integer.
5840  ret + "" :
5841  ret;
5842 }
5843 
5844 
5845 function addGetHookIf( conditionFn, hookFn ) {
5846 
5847  // Define the hook, we'll check on the first run if it's really needed.
5848  return {
5849  get: function() {
5850  if ( conditionFn() ) {
5851 
5852  // Hook not needed (or it's not possible to use it due
5853  // to missing dependency), remove it.
5854  delete this.get;
5855  return;
5856  }
5857 
5858  // Hook needed; redefine it so that the support test is not executed again.
5859  return ( this.get = hookFn ).apply( this, arguments );
5860  }
5861  };
5862 }
5863 
5864 
5865 var
5866 
5867  // Swappable if display is none or starts with table
5868  // except "table", "table-cell", or "table-caption"
5869  // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
5870  rdisplayswap = /^(none|table(?!-c[ea]).+)/,
5871 
5872  cssShow = { position: "absolute", visibility: "hidden", display: "block" },
5873  cssNormalTransform = {
5874  letterSpacing: "0",
5875  fontWeight: "400"
5876  },
5877 
5878  cssPrefixes = [ "Webkit", "O", "Moz", "ms" ],
5879  emptyStyle = document.createElement( "div" ).style;
5880 
5881 // Return a css property mapped to a potentially vendor prefixed property
5882 function vendorPropName( name ) {
5883 
5884  // Shortcut for names that are not vendor prefixed
5885  if ( name in emptyStyle ) {
5886  return name;
5887  }
5888 
5889  // Check for vendor prefixed names
5890  var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
5891  i = cssPrefixes.length;
5892 
5893  while ( i-- ) {
5894  name = cssPrefixes[ i ] + capName;
5895  if ( name in emptyStyle ) {
5896  return name;
5897  }
5898  }
5899 }
5900 
5901 function setPositiveNumber( elem, value, subtract ) {
5902 
5903  // Any relative (+/-) values have already been
5904  // normalized at this point
5905  var matches = rcssNum.exec( value );
5906  return matches ?
5907 
5908  // Guard against undefined "subtract", e.g., when used as in cssHooks
5909  Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
5910  value;
5911 }
5912 
5913 function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
5914  var i = extra === ( isBorderBox ? "border" : "content" ) ?
5915 
5916  // If we already have the right measurement, avoid augmentation
5917  4 :
5918 
5919  // Otherwise initialize for horizontal or vertical properties
5920  name === "width" ? 1 : 0,
5921 
5922  val = 0;
5923 
5924  for ( ; i < 4; i += 2 ) {
5925 
5926  // Both box models exclude margin, so add it if we want it
5927  if ( extra === "margin" ) {
5928  val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
5929  }
5930 
5931  if ( isBorderBox ) {
5932 
5933  // border-box includes padding, so remove it if we want content
5934  if ( extra === "content" ) {
5935  val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
5936  }
5937 
5938  // At this point, extra isn't border nor margin, so remove border
5939  if ( extra !== "margin" ) {
5940  val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
5941  }
5942  } else {
5943 
5944  // At this point, extra isn't content, so add padding
5945  val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
5946 
5947  // At this point, extra isn't content nor padding, so add border
5948  if ( extra !== "padding" ) {
5949  val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
5950  }
5951  }
5952  }
5953 
5954  return val;
5955 }
5956 
5957 function getWidthOrHeight( elem, name, extra ) {
5958 
5959  // Start with offset property, which is equivalent to the border-box value
5960  var valueIsBorderBox = true,
5961  val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
5962  styles = getStyles( elem ),
5963  isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
5964 
5965  // Some non-html elements return undefined for offsetWidth, so check for null/undefined
5966  // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
5967  // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
5968  if ( val <= 0 || val == null ) {
5969 
5970  // Fall back to computed then uncomputed css if necessary
5971  val = curCSS( elem, name, styles );
5972  if ( val < 0 || val == null ) {
5973  val = elem.style[ name ];
5974  }
5975 
5976  // Computed unit is not pixels. Stop here and return.
5977  if ( rnumnonpx.test( val ) ) {
5978  return val;
5979  }
5980 
5981  // Check for style in case a browser which returns unreliable values
5982  // for getComputedStyle silently falls back to the reliable elem.style
5983  valueIsBorderBox = isBorderBox &&
5984  ( support.boxSizingReliable() || val === elem.style[ name ] );
5985 
5986  // Normalize "", auto, and prepare for extra
5987  val = parseFloat( val ) || 0;
5988  }
5989 
5990  // Use the active box-sizing model to add/subtract irrelevant styles
5991  return ( val +
5992  augmentWidthOrHeight(
5993  elem,
5994  name,
5995  extra || ( isBorderBox ? "border" : "content" ),
5996  valueIsBorderBox,
5997  styles
5998  )
5999  ) + "px";
6000 }
6001 
6002 function showHide( elements, show ) {
6003  var display, elem, hidden,
6004  values = [],
6005  index = 0,
6006  length = elements.length;
6007 
6008  for ( ; index < length; index++ ) {
6009  elem = elements[ index ];
6010  if ( !elem.style ) {
6011  continue;
6012  }
6013 
6014  values[ index ] = dataPriv.get( elem, "olddisplay" );
6015  display = elem.style.display;
6016  if ( show ) {
6017 
6018  // Reset the inline display of this element to learn if it is
6019  // being hidden by cascaded rules or not
6020  if ( !values[ index ] && display === "none" ) {
6021  elem.style.display = "";
6022  }
6023 
6024  // Set elements which have been overridden with display: none
6025  // in a stylesheet to whatever the default browser style is
6026  // for such an element
6027  if ( elem.style.display === "" && isHidden( elem ) ) {
6028  values[ index ] = dataPriv.access(
6029  elem,
6030  "olddisplay",
6031  defaultDisplay( elem.nodeName )
6032  );
6033  }
6034  } else {
6035  hidden = isHidden( elem );
6036 
6037  if ( display !== "none" || !hidden ) {
6038  dataPriv.set(
6039  elem,
6040  "olddisplay",
6041  hidden ? display : jQuery.css( elem, "display" )
6042  );
6043  }
6044  }
6045  }
6046 
6047  // Set the display of most of the elements in a second loop
6048  // to avoid the constant reflow
6049  for ( index = 0; index < length; index++ ) {
6050  elem = elements[ index ];
6051  if ( !elem.style ) {
6052  continue;
6053  }
6054  if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
6055  elem.style.display = show ? values[ index ] || "" : "none";
6056  }
6057  }
6058 
6059  return elements;
6060 }
6061 
6062 jQuery.extend( {
6063 
6064  // Add in style property hooks for overriding the default
6065  // behavior of getting and setting a style property
6066  cssHooks: {
6067  opacity: {
6068  get: function( elem, computed ) {
6069  if ( computed ) {
6070 
6071  // We should always get a number back from opacity
6072  var ret = curCSS( elem, "opacity" );
6073  return ret === "" ? "1" : ret;
6074  }
6075  }
6076  }
6077  },
6078 
6079  // Don't automatically add "px" to these possibly-unitless properties
6080  cssNumber: {
6081  "animationIterationCount": true,
6082  "columnCount": true,
6083  "fillOpacity": true,
6084  "flexGrow": true,
6085  "flexShrink": true,
6086  "fontWeight": true,
6087  "lineHeight": true,
6088  "opacity": true,
6089  "order": true,
6090  "orphans": true,
6091  "widows": true,
6092  "zIndex": true,
6093  "zoom": true
6094  },
6095 
6096  // Add in properties whose names you wish to fix before
6097  // setting or getting the value
6098  cssProps: {
6099  "float": "cssFloat"
6100  },
6101 
6102  // Get and set the style property on a DOM Node
6103  style: function( elem, name, value, extra ) {
6104 
6105  // Don't set styles on text and comment nodes
6106  if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6107  return;
6108  }
6109 
6110  // Make sure that we're working with the right name
6111  var ret, type, hooks,
6112  origName = jQuery.camelCase( name ),
6113  style = elem.style;
6114 
6115  name = jQuery.cssProps[ origName ] ||
6116  ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
6117 
6118  // Gets hook for the prefixed version, then unprefixed version
6119  hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6120 
6121  // Check if we're setting a value
6122  if ( value !== undefined ) {
6123  type = typeof value;
6124 
6125  // Convert "+=" or "-=" to relative numbers (#7345)
6126  if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
6127  value = adjustCSS( elem, name, ret );
6128 
6129  // Fixes bug #9237
6130  type = "number";
6131  }
6132 
6133  // Make sure that null and NaN values aren't set (#7116)
6134  if ( value == null || value !== value ) {
6135  return;
6136  }
6137 
6138  // If a number was passed in, add the unit (except for certain CSS properties)
6139  if ( type === "number" ) {
6140  value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
6141  }
6142 
6143  // Support: IE9-11+
6144  // background-* props affect original clone's values
6145  if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
6146  style[ name ] = "inherit";
6147  }
6148 
6149  // If a hook was provided, use that value, otherwise just set the specified value
6150  if ( !hooks || !( "set" in hooks ) ||
6151  ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
6152 
6153  style[ name ] = value;
6154  }
6155 
6156  } else {
6157 
6158  // If a hook was provided get the non-computed value from there
6159  if ( hooks && "get" in hooks &&
6160  ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
6161 
6162  return ret;
6163  }
6164 
6165  // Otherwise just get the value from the style object
6166  return style[ name ];
6167  }
6168  },
6169 
6170  css: function( elem, name, extra, styles ) {
6171  var val, num, hooks,
6172  origName = jQuery.camelCase( name );
6173 
6174  // Make sure that we're working with the right name
6175  name = jQuery.cssProps[ origName ] ||
6176  ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
6177 
6178  // Try prefixed name followed by the unprefixed name
6179  hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6180 
6181  // If a hook was provided get the computed value from there
6182  if ( hooks && "get" in hooks ) {
6183  val = hooks.get( elem, true, extra );
6184  }
6185 
6186  // Otherwise, if a way to get the computed value exists, use that
6187  if ( val === undefined ) {
6188  val = curCSS( elem, name, styles );
6189  }
6190 
6191  // Convert "normal" to computed value
6192  if ( val === "normal" && name in cssNormalTransform ) {
6193  val = cssNormalTransform[ name ];
6194  }
6195 
6196  // Make numeric if forced or a qualifier was provided and val looks numeric
6197  if ( extra === "" || extra ) {
6198  num = parseFloat( val );
6199  return extra === true || isFinite( num ) ? num || 0 : val;
6200  }
6201  return val;
6202  }
6203 } );
6204 
6205 jQuery.each( [ "height", "width" ], function( i, name ) {
6206  jQuery.cssHooks[ name ] = {
6207  get: function( elem, computed, extra ) {
6208  if ( computed ) {
6209 
6210  // Certain elements can have dimension info if we invisibly show them
6211  // but it must have a current display style that would benefit
6212  return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
6213  elem.offsetWidth === 0 ?
6214  swap( elem, cssShow, function() {
6215  return getWidthOrHeight( elem, name, extra );
6216  } ) :
6217  getWidthOrHeight( elem, name, extra );
6218  }
6219  },
6220 
6221  set: function( elem, value, extra ) {
6222  var matches,
6223  styles = extra && getStyles( elem ),
6224  subtract = extra && augmentWidthOrHeight(
6225  elem,
6226  name,
6227  extra,
6228  jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6229  styles
6230  );
6231 
6232  // Convert to pixels if value adjustment is needed
6233  if ( subtract && ( matches = rcssNum.exec( value ) ) &&
6234  ( matches[ 3 ] || "px" ) !== "px" ) {
6235 
6236  elem.style[ name ] = value;
6237  value = jQuery.css( elem, name );
6238  }
6239 
6240  return setPositiveNumber( elem, value, subtract );
6241  }
6242  };
6243 } );
6244 
6245 jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
6246  function( elem, computed ) {
6247  if ( computed ) {
6248  return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
6249  elem.getBoundingClientRect().left -
6250  swap( elem, { marginLeft: 0 }, function() {
6251  return elem.getBoundingClientRect().left;
6252  } )
6253  ) + "px";
6254  }
6255  }
6256 );
6257 
6258 // Support: Android 2.3
6259 jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
6260  function( elem, computed ) {
6261  if ( computed ) {
6262  return swap( elem, { "display": "inline-block" },
6263  curCSS, [ elem, "marginRight" ] );
6264  }
6265  }
6266 );
6267 
6268 // These hooks are used by animate to expand properties
6269 jQuery.each( {
6270  margin: "",
6271  padding: "",
6272  border: "Width"
6273 }, function( prefix, suffix ) {
6274  jQuery.cssHooks[ prefix + suffix ] = {
6275  expand: function( value ) {
6276  var i = 0,
6277  expanded = {},
6278 
6279  // Assumes a single number if not a string
6280  parts = typeof value === "string" ? value.split( " " ) : [ value ];
6281 
6282  for ( ; i < 4; i++ ) {
6283  expanded[ prefix + cssExpand[ i ] + suffix ] =
6284  parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
6285  }
6286 
6287  return expanded;
6288  }
6289  };
6290 
6291  if ( !rmargin.test( prefix ) ) {
6292  jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
6293  }
6294 } );
6295 
6296 jQuery.fn.extend( {
6297  css: function( name, value ) {
6298  return access( this, function( elem, name, value ) {
6299  var styles, len,
6300  map = {},
6301  i = 0;
6302 
6303  if ( jQuery.isArray( name ) ) {
6304  styles = getStyles( elem );
6305  len = name.length;
6306 
6307  for ( ; i < len; i++ ) {
6308  map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
6309  }
6310 
6311  return map;
6312  }
6313 
6314  return value !== undefined ?
6315  jQuery.style( elem, name, value ) :
6316  jQuery.css( elem, name );
6317  }, name, value, arguments.length > 1 );
6318  },
6319  show: function() {
6320  return showHide( this, true );
6321  },
6322  hide: function() {
6323  return showHide( this );
6324  },
6325  toggle: function( state ) {
6326  if ( typeof state === "boolean" ) {
6327  return state ? this.show() : this.hide();
6328  }
6329 
6330  return this.each( function() {
6331  if ( isHidden( this ) ) {
6332  jQuery( this ).show();
6333  } else {
6334  jQuery( this ).hide();
6335  }
6336  } );
6337  }
6338 } );
6339 
6340 
6341 function Tween( elem, options, prop, end, easing ) {
6342  return new Tween.prototype.init( elem, options, prop, end, easing );
6343 }
6344 jQuery.Tween = Tween;
6345 
6346 Tween.prototype = {
6347  constructor: Tween,
6348  init: function( elem, options, prop, end, easing, unit ) {
6349  this.elem = elem;
6350  this.prop = prop;
6351  this.easing = easing || jQuery.easing._default;
6352  this.options = options;
6353  this.start = this.now = this.cur();
6354  this.end = end;
6355  this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
6356  },
6357  cur: function() {
6358  var hooks = Tween.propHooks[ this.prop ];
6359 
6360  return hooks && hooks.get ?
6361  hooks.get( this ) :
6362  Tween.propHooks._default.get( this );
6363  },
6364  run: function( percent ) {
6365  var eased,
6366  hooks = Tween.propHooks[ this.prop ];
6367 
6368  if ( this.options.duration ) {
6369  this.pos = eased = jQuery.easing[ this.easing ](
6370  percent, this.options.duration * percent, 0, 1, this.options.duration
6371  );
6372  } else {
6373  this.pos = eased = percent;
6374  }
6375  this.now = ( this.end - this.start ) * eased + this.start;
6376 
6377  if ( this.options.step ) {
6378  this.options.step.call( this.elem, this.now, this );
6379  }
6380 
6381  if ( hooks && hooks.set ) {
6382  hooks.set( this );
6383  } else {
6384  Tween.propHooks._default.set( this );
6385  }
6386  return this;
6387  }
6388 };
6389 
6390 Tween.prototype.init.prototype = Tween.prototype;
6391 
6392 Tween.propHooks = {
6393  _default: {
6394  get: function( tween ) {
6395  var result;
6396 
6397  // Use a property on the element directly when it is not a DOM element,
6398  // or when there is no matching style property that exists.
6399  if ( tween.elem.nodeType !== 1 ||
6400  tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
6401  return tween.elem[ tween.prop ];
6402  }
6403 
6404  // Passing an empty string as a 3rd parameter to .css will automatically
6405  // attempt a parseFloat and fallback to a string if the parse fails.
6406  // Simple values such as "10px" are parsed to Float;
6407  // complex values such as "rotate(1rad)" are returned as-is.
6408  result = jQuery.css( tween.elem, tween.prop, "" );
6409 
6410  // Empty strings, null, undefined and "auto" are converted to 0.
6411  return !result || result === "auto" ? 0 : result;
6412  },
6413  set: function( tween ) {
6414 
6415  // Use step hook for back compat.
6416  // Use cssHook if its there.
6417  // Use .style if available and use plain properties where available.
6418  if ( jQuery.fx.step[ tween.prop ] ) {
6419  jQuery.fx.step[ tween.prop ]( tween );
6420  } else if ( tween.elem.nodeType === 1 &&
6421  ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
6422  jQuery.cssHooks[ tween.prop ] ) ) {
6423  jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
6424  } else {
6425  tween.elem[ tween.prop ] = tween.now;
6426  }
6427  }
6428  }
6429 };
6430 
6431 // Support: IE9
6432 // Panic based approach to setting things on disconnected nodes
6433 Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
6434  set: function( tween ) {
6435  if ( tween.elem.nodeType && tween.elem.parentNode ) {
6436  tween.elem[ tween.prop ] = tween.now;
6437  }
6438  }
6439 };
6440 
6441 jQuery.easing = {
6442  linear: function( p ) {
6443  return p;
6444  },
6445  swing: function( p ) {
6446  return 0.5 - Math.cos( p * Math.PI ) / 2;
6447  },
6448  _default: "swing"
6449 };
6450 
6451 jQuery.fx = Tween.prototype.init;
6452 
6453 // Back Compat <1.8 extension point
6454 jQuery.fx.step = {};
6455 
6456 
6457 
6458 
6459 var
6460  fxNow, timerId,
6461  rfxtypes = /^(?:toggle|show|hide)$/,
6462  rrun = /queueHooks$/;
6463 
6464 // Animations created synchronously will run synchronously
6465 function createFxNow() {
6466  window.setTimeout( function() {
6467  fxNow = undefined;
6468  } );
6469  return ( fxNow = jQuery.now() );
6470 }
6471 
6472 // Generate parameters to create a standard animation
6473 function genFx( type, includeWidth ) {
6474  var which,
6475  i = 0,
6476  attrs = { height: type };
6477 
6478  // If we include width, step value is 1 to do all cssExpand values,
6479  // otherwise step value is 2 to skip over Left and Right
6480  includeWidth = includeWidth ? 1 : 0;
6481  for ( ; i < 4 ; i += 2 - includeWidth ) {
6482  which = cssExpand[ i ];
6483  attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
6484  }
6485 
6486  if ( includeWidth ) {
6487  attrs.opacity = attrs.width = type;
6488  }
6489 
6490  return attrs;
6491 }
6492 
6493 function createTween( value, prop, animation ) {
6494  var tween,
6495  collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
6496  index = 0,
6497  length = collection.length;
6498  for ( ; index < length; index++ ) {
6499  if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
6500 
6501  // We're done with this property
6502  return tween;
6503  }
6504  }
6505 }
6506 
6507 function defaultPrefilter( elem, props, opts ) {
6508  /* jshint validthis: true */
6509  var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
6510  anim = this,
6511  orig = {},
6512  style = elem.style,
6513  hidden = elem.nodeType && isHidden( elem ),
6514  dataShow = dataPriv.get( elem, "fxshow" );
6515 
6516  // Handle queue: false promises
6517  if ( !opts.queue ) {
6518  hooks = jQuery._queueHooks( elem, "fx" );
6519  if ( hooks.unqueued == null ) {
6520  hooks.unqueued = 0;
6521  oldfire = hooks.empty.fire;
6522  hooks.empty.fire = function() {
6523  if ( !hooks.unqueued ) {
6524  oldfire();
6525  }
6526  };
6527  }
6528  hooks.unqueued++;
6529 
6530  anim.always( function() {
6531 
6532  // Ensure the complete handler is called before this completes
6533  anim.always( function() {
6534  hooks.unqueued--;
6535  if ( !jQuery.queue( elem, "fx" ).length ) {
6536  hooks.empty.fire();
6537  }
6538  } );
6539  } );
6540  }
6541 
6542  // Height/width overflow pass
6543  if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
6544 
6545  // Make sure that nothing sneaks out
6546  // Record all 3 overflow attributes because IE9-10 do not
6547  // change the overflow attribute when overflowX and
6548  // overflowY are set to the same value
6549  opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
6550 
6551  // Set display property to inline-block for height/width
6552  // animations on inline elements that are having width/height animated
6553  display = jQuery.css( elem, "display" );
6554 
6555  // Test default display if display is currently "none"
6556  checkDisplay = display === "none" ?
6557  dataPriv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
6558 
6559  if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
6560  style.display = "inline-block";
6561  }
6562  }
6563 
6564  if ( opts.overflow ) {
6565  style.overflow = "hidden";
6566  anim.always( function() {
6567  style.overflow = opts.overflow[ 0 ];
6568  style.overflowX = opts.overflow[ 1 ];
6569  style.overflowY = opts.overflow[ 2 ];
6570  } );
6571  }
6572 
6573  // show/hide pass
6574  for ( prop in props ) {
6575  value = props[ prop ];
6576  if ( rfxtypes.exec( value ) ) {
6577  delete props[ prop ];
6578  toggle = toggle || value === "toggle";
6579  if ( value === ( hidden ? "hide" : "show" ) ) {
6580 
6581  // If there is dataShow left over from a stopped hide or show
6582  // and we are going to proceed with show, we should pretend to be hidden
6583  if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
6584  hidden = true;
6585  } else {
6586  continue;
6587  }
6588  }
6589  orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
6590 
6591  // Any non-fx value stops us from restoring the original display value
6592  } else {
6593  display = undefined;
6594  }
6595  }
6596 
6597  if ( !jQuery.isEmptyObject( orig ) ) {
6598  if ( dataShow ) {
6599  if ( "hidden" in dataShow ) {
6600  hidden = dataShow.hidden;
6601  }
6602  } else {
6603  dataShow = dataPriv.access( elem, "fxshow", {} );
6604  }
6605 
6606  // Store state if its toggle - enables .stop().toggle() to "reverse"
6607  if ( toggle ) {
6608  dataShow.hidden = !hidden;
6609  }
6610  if ( hidden ) {
6611  jQuery( elem ).show();
6612  } else {
6613  anim.done( function() {
6614  jQuery( elem ).hide();
6615  } );
6616  }
6617  anim.done( function() {
6618  var prop;
6619 
6620  dataPriv.remove( elem, "fxshow" );
6621  for ( prop in orig ) {
6622  jQuery.style( elem, prop, orig[ prop ] );
6623  }
6624  } );
6625  for ( prop in orig ) {
6626  tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
6627 
6628  if ( !( prop in dataShow ) ) {
6629  dataShow[ prop ] = tween.start;
6630  if ( hidden ) {
6631  tween.end = tween.start;
6632  tween.start = prop === "width" || prop === "height" ? 1 : 0;
6633  }
6634  }
6635  }
6636 
6637  // If this is a noop like .hide().hide(), restore an overwritten display value
6638  } else if ( ( display === "none" ? defaultDisplay( elem.nodeName ) : display ) === "inline" ) {
6639  style.display = display;
6640  }
6641 }
6642 
6643 function propFilter( props, specialEasing ) {
6644  var index, name, easing, value, hooks;
6645 
6646  // camelCase, specialEasing and expand cssHook pass
6647  for ( index in props ) {
6648  name = jQuery.camelCase( index );
6649  easing = specialEasing[ name ];
6650  value = props[ index ];
6651  if ( jQuery.isArray( value ) ) {
6652  easing = value[ 1 ];
6653  value = props[ index ] = value[ 0 ];
6654  }
6655 
6656  if ( index !== name ) {
6657  props[ name ] = value;
6658  delete props[ index ];
6659  }
6660 
6661  hooks = jQuery.cssHooks[ name ];
6662  if ( hooks && "expand" in hooks ) {
6663  value = hooks.expand( value );
6664  delete props[ name ];
6665 
6666  // Not quite $.extend, this won't overwrite existing keys.
6667  // Reusing 'index' because we have the correct "name"
6668  for ( index in value ) {
6669  if ( !( index in props ) ) {
6670  props[ index ] = value[ index ];
6671  specialEasing[ index ] = easing;
6672  }
6673  }
6674  } else {
6675  specialEasing[ name ] = easing;
6676  }
6677  }
6678 }
6679 
6680 function Animation( elem, properties, options ) {
6681  var result,
6682  stopped,
6683  index = 0,
6684  length = Animation.prefilters.length,
6685  deferred = jQuery.Deferred().always( function() {
6686 
6687  // Don't match elem in the :animated selector
6688  delete tick.elem;
6689  } ),
6690  tick = function() {
6691  if ( stopped ) {
6692  return false;
6693  }
6694  var currentTime = fxNow || createFxNow(),
6695  remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
6696 
6697  // Support: Android 2.3
6698  // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
6699  temp = remaining / animation.duration || 0,
6700  percent = 1 - temp,
6701  index = 0,
6702  length = animation.tweens.length;
6703 
6704  for ( ; index < length ; index++ ) {
6705  animation.tweens[ index ].run( percent );
6706  }
6707 
6708  deferred.notifyWith( elem, [ animation, percent, remaining ] );
6709 
6710  if ( percent < 1 && length ) {
6711  return remaining;
6712  } else {
6713  deferred.resolveWith( elem, [ animation ] );
6714  return false;
6715  }
6716  },
6717  animation = deferred.promise( {
6718  elem: elem,
6719  props: jQuery.extend( {}, properties ),
6720  opts: jQuery.extend( true, {
6721  specialEasing: {},
6722  easing: jQuery.easing._default
6723  }, options ),
6724  originalProperties: properties,
6725  originalOptions: options,
6726  startTime: fxNow || createFxNow(),
6727  duration: options.duration,
6728  tweens: [],
6729  createTween: function( prop, end ) {
6730  var tween = jQuery.Tween( elem, animation.opts, prop, end,
6731  animation.opts.specialEasing[ prop ] || animation.opts.easing );
6732  animation.tweens.push( tween );
6733  return tween;
6734  },
6735  stop: function( gotoEnd ) {
6736  var index = 0,
6737 
6738  // If we are going to the end, we want to run all the tweens
6739  // otherwise we skip this part
6740  length = gotoEnd ? animation.tweens.length : 0;
6741  if ( stopped ) {
6742  return this;
6743  }
6744  stopped = true;
6745  for ( ; index < length ; index++ ) {
6746  animation.tweens[ index ].run( 1 );
6747  }
6748 
6749  // Resolve when we played the last frame; otherwise, reject
6750  if ( gotoEnd ) {
6751  deferred.notifyWith( elem, [ animation, 1, 0 ] );
6752  deferred.resolveWith( elem, [ animation, gotoEnd ] );
6753  } else {
6754  deferred.rejectWith( elem, [ animation, gotoEnd ] );
6755  }
6756  return this;
6757  }
6758  } ),
6759  props = animation.props;
6760 
6761  propFilter( props, animation.opts.specialEasing );
6762 
6763  for ( ; index < length ; index++ ) {
6764  result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
6765  if ( result ) {
6766  if ( jQuery.isFunction( result.stop ) ) {
6767  jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
6768  jQuery.proxy( result.stop, result );
6769  }
6770  return result;
6771  }
6772  }
6773 
6774  jQuery.map( props, createTween, animation );
6775 
6776  if ( jQuery.isFunction( animation.opts.start ) ) {
6777  animation.opts.start.call( elem, animation );
6778  }
6779 
6780  jQuery.fx.timer(
6781  jQuery.extend( tick, {
6782  elem: elem,
6783  anim: animation,
6784  queue: animation.opts.queue
6785  } )
6786  );
6787 
6788  // attach callbacks from options
6789  return animation.progress( animation.opts.progress )
6790  .done( animation.opts.done, animation.opts.complete )
6791  .fail( animation.opts.fail )
6792  .always( animation.opts.always );
6793 }
6794 
6795 jQuery.Animation = jQuery.extend( Animation, {
6796  tweeners: {
6797  "*": [ function( prop, value ) {
6798  var tween = this.createTween( prop, value );
6799  adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
6800  return tween;
6801  } ]
6802  },
6803 
6804  tweener: function( props, callback ) {
6805  if ( jQuery.isFunction( props ) ) {
6806  callback = props;
6807  props = [ "*" ];
6808  } else {
6809  props = props.match( rnotwhite );
6810  }
6811 
6812  var prop,
6813  index = 0,
6814  length = props.length;
6815 
6816  for ( ; index < length ; index++ ) {
6817  prop = props[ index ];
6818  Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
6819  Animation.tweeners[ prop ].unshift( callback );
6820  }
6821  },
6822 
6823  prefilters: [ defaultPrefilter ],
6824 
6825  prefilter: function( callback, prepend ) {
6826  if ( prepend ) {
6827  Animation.prefilters.unshift( callback );
6828  } else {
6829  Animation.prefilters.push( callback );
6830  }
6831  }
6832 } );
6833 
6834 jQuery.speed = function( speed, easing, fn ) {
6835  var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
6836  complete: fn || !fn && easing ||
6837  jQuery.isFunction( speed ) && speed,
6838  duration: speed,
6839  easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
6840  };
6841 
6842  opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ?
6843  opt.duration : opt.duration in jQuery.fx.speeds ?
6844  jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
6845 
6846  // Normalize opt.queue - true/undefined/null -> "fx"
6847  if ( opt.queue == null || opt.queue === true ) {
6848  opt.queue = "fx";
6849  }
6850 
6851  // Queueing
6852  opt.old = opt.complete;
6853 
6854  opt.complete = function() {
6855  if ( jQuery.isFunction( opt.old ) ) {
6856  opt.old.call( this );
6857  }
6858 
6859  if ( opt.queue ) {
6860  jQuery.dequeue( this, opt.queue );
6861  }
6862  };
6863 
6864  return opt;
6865 };
6866 
6867 jQuery.fn.extend( {
6868  fadeTo: function( speed, to, easing, callback ) {
6869 
6870  // Show any hidden elements after setting opacity to 0
6871  return this.filter( isHidden ).css( "opacity", 0 ).show()
6872 
6873  // Animate to the value specified
6874  .end().animate( { opacity: to }, speed, easing, callback );
6875  },
6876  animate: function( prop, speed, easing, callback ) {
6877  var empty = jQuery.isEmptyObject( prop ),
6878  optall = jQuery.speed( speed, easing, callback ),
6879  doAnimation = function() {
6880 
6881  // Operate on a copy of prop so per-property easing won't be lost
6882  var anim = Animation( this, jQuery.extend( {}, prop ), optall );
6883 
6884  // Empty animations, or finishing resolves immediately
6885  if ( empty || dataPriv.get( this, "finish" ) ) {
6886  anim.stop( true );
6887  }
6888  };
6889  doAnimation.finish = doAnimation;
6890 
6891  return empty || optall.queue === false ?
6892  this.each( doAnimation ) :
6893  this.queue( optall.queue, doAnimation );
6894  },
6895  stop: function( type, clearQueue, gotoEnd ) {
6896  var stopQueue = function( hooks ) {
6897  var stop = hooks.stop;
6898  delete hooks.stop;
6899  stop( gotoEnd );
6900  };
6901 
6902  if ( typeof type !== "string" ) {
6903  gotoEnd = clearQueue;
6904  clearQueue = type;
6905  type = undefined;
6906  }
6907  if ( clearQueue && type !== false ) {
6908  this.queue( type || "fx", [] );
6909  }
6910 
6911  return this.each( function() {
6912  var dequeue = true,
6913  index = type != null && type + "queueHooks",
6914  timers = jQuery.timers,
6915  data = dataPriv.get( this );
6916 
6917  if ( index ) {
6918  if ( data[ index ] && data[ index ].stop ) {
6919  stopQueue( data[ index ] );
6920  }
6921  } else {
6922  for ( index in data ) {
6923  if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
6924  stopQueue( data[ index ] );
6925  }
6926  }
6927  }
6928 
6929  for ( index = timers.length; index--; ) {
6930  if ( timers[ index ].elem === this &&
6931  ( type == null || timers[ index ].queue === type ) ) {
6932 
6933  timers[ index ].anim.stop( gotoEnd );
6934  dequeue = false;
6935  timers.splice( index, 1 );
6936  }
6937  }
6938 
6939  // Start the next in the queue if the last step wasn't forced.
6940  // Timers currently will call their complete callbacks, which
6941  // will dequeue but only if they were gotoEnd.
6942  if ( dequeue || !gotoEnd ) {
6943  jQuery.dequeue( this, type );
6944  }
6945  } );
6946  },
6947  finish: function( type ) {
6948  if ( type !== false ) {
6949  type = type || "fx";
6950  }
6951  return this.each( function() {
6952  var index,
6953  data = dataPriv.get( this ),
6954  queue = data[ type + "queue" ],
6955  hooks = data[ type + "queueHooks" ],
6956  timers = jQuery.timers,
6957  length = queue ? queue.length : 0;
6958 
6959  // Enable finishing flag on private data
6960  data.finish = true;
6961 
6962  // Empty the queue first
6963  jQuery.queue( this, type, [] );
6964 
6965  if ( hooks && hooks.stop ) {
6966  hooks.stop.call( this, true );
6967  }
6968 
6969  // Look for any active animations, and finish them
6970  for ( index = timers.length; index--; ) {
6971  if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
6972  timers[ index ].anim.stop( true );
6973  timers.splice( index, 1 );
6974  }
6975  }
6976 
6977  // Look for any animations in the old queue and finish them
6978  for ( index = 0; index < length; index++ ) {
6979  if ( queue[ index ] && queue[ index ].finish ) {
6980  queue[ index ].finish.call( this );
6981  }
6982  }
6983 
6984  // Turn off finishing flag
6985  delete data.finish;
6986  } );
6987  }
6988 } );
6989 
6990 jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
6991  var cssFn = jQuery.fn[ name ];
6992  jQuery.fn[ name ] = function( speed, easing, callback ) {
6993  return speed == null || typeof speed === "boolean" ?
6994  cssFn.apply( this, arguments ) :
6995  this.animate( genFx( name, true ), speed, easing, callback );
6996  };
6997 } );
6998 
6999 // Generate shortcuts for custom animations
7000 jQuery.each( {
7001  slideDown: genFx( "show" ),
7002  slideUp: genFx( "hide" ),
7003  slideToggle: genFx( "toggle" ),
7004  fadeIn: { opacity: "show" },
7005  fadeOut: { opacity: "hide" },
7006  fadeToggle: { opacity: "toggle" }
7007 }, function( name, props ) {
7008  jQuery.fn[ name ] = function( speed, easing, callback ) {
7009  return this.animate( props, speed, easing, callback );
7010  };
7011 } );
7012 
7013 jQuery.timers = [];
7014 jQuery.fx.tick = function() {
7015  var timer,
7016  i = 0,
7017  timers = jQuery.timers;
7018 
7019  fxNow = jQuery.now();
7020 
7021  for ( ; i < timers.length; i++ ) {
7022  timer = timers[ i ];
7023 
7024  // Checks the timer has not already been removed
7025  if ( !timer() && timers[ i ] === timer ) {
7026  timers.splice( i--, 1 );
7027  }
7028  }
7029 
7030  if ( !timers.length ) {
7031  jQuery.fx.stop();
7032  }
7033  fxNow = undefined;
7034 };
7035 
7036 jQuery.fx.timer = function( timer ) {
7037  jQuery.timers.push( timer );
7038  if ( timer() ) {
7039  jQuery.fx.start();
7040  } else {
7041  jQuery.timers.pop();
7042  }
7043 };
7044 
7045 jQuery.fx.interval = 13;
7046 jQuery.fx.start = function() {
7047  if ( !timerId ) {
7048  timerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval );
7049  }
7050 };
7051 
7052 jQuery.fx.stop = function() {
7053  window.clearInterval( timerId );
7054 
7055  timerId = null;
7056 };
7057 
7058 jQuery.fx.speeds = {
7059  slow: 600,
7060  fast: 200,
7061 
7062  // Default speed
7063  _default: 400
7064 };
7065 
7066 
7067 // Based off of the plugin by Clint Helfers, with permission.
7068 // http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
7069 jQuery.fn.delay = function( time, type ) {
7070  time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
7071  type = type || "fx";
7072 
7073  return this.queue( type, function( next, hooks ) {
7074  var timeout = window.setTimeout( next, time );
7075  hooks.stop = function() {
7076  window.clearTimeout( timeout );
7077  };
7078  } );
7079 };
7080 
7081 
7082 ( function() {
7083  var input = document.createElement( "input" ),
7084  select = document.createElement( "select" ),
7085  opt = select.appendChild( document.createElement( "option" ) );
7086 
7087  input.type = "checkbox";
7088 
7089  // Support: iOS<=5.1, Android<=4.2+
7090  // Default value for a checkbox should be "on"
7091  support.checkOn = input.value !== "";
7092 
7093  // Support: IE<=11+
7094  // Must access selectedIndex to make default options select
7095  support.optSelected = opt.selected;
7096 
7097  // Support: Android<=2.3
7098  // Options inside disabled selects are incorrectly marked as disabled
7099  select.disabled = true;
7100  support.optDisabled = !opt.disabled;
7101 
7102  // Support: IE<=11+
7103  // An input loses its value after becoming a radio
7104  input = document.createElement( "input" );
7105  input.value = "t";
7106  input.type = "radio";
7107  support.radioValue = input.value === "t";
7108 } )();
7109 
7110 
7111 var boolHook,
7112  attrHandle = jQuery.expr.attrHandle;
7113 
7114 jQuery.fn.extend( {
7115  attr: function( name, value ) {
7116  return access( this, jQuery.attr, name, value, arguments.length > 1 );
7117  },
7118 
7119  removeAttr: function( name ) {
7120  return this.each( function() {
7121  jQuery.removeAttr( this, name );
7122  } );
7123  }
7124 } );
7125 
7126 jQuery.extend( {
7127  attr: function( elem, name, value ) {
7128  var ret, hooks,
7129  nType = elem.nodeType;
7130 
7131  // Don't get/set attributes on text, comment and attribute nodes
7132  if ( nType === 3 || nType === 8 || nType === 2 ) {
7133  return;
7134  }
7135 
7136  // Fallback to prop when attributes are not supported
7137  if ( typeof elem.getAttribute === "undefined" ) {
7138  return jQuery.prop( elem, name, value );
7139  }
7140 
7141  // All attributes are lowercase
7142  // Grab necessary hook if one is defined
7143  if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7144  name = name.toLowerCase();
7145  hooks = jQuery.attrHooks[ name ] ||
7146  ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
7147  }
7148 
7149  if ( value !== undefined ) {
7150  if ( value === null ) {
7151  jQuery.removeAttr( elem, name );
7152  return;
7153  }
7154 
7155  if ( hooks && "set" in hooks &&
7156  ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7157  return ret;
7158  }
7159 
7160  elem.setAttribute( name, value + "" );
7161  return value;
7162  }
7163 
7164  if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7165  return ret;
7166  }
7167 
7168  ret = jQuery.find.attr( elem, name );
7169 
7170  // Non-existent attributes return null, we normalize to undefined
7171  return ret == null ? undefined : ret;
7172  },
7173 
7174  attrHooks: {
7175  type: {
7176  set: function( elem, value ) {
7177  if ( !support.radioValue && value === "radio" &&
7178  jQuery.nodeName( elem, "input" ) ) {
7179  var val = elem.value;
7180  elem.setAttribute( "type", value );
7181  if ( val ) {
7182  elem.value = val;
7183  }
7184  return value;
7185  }
7186  }
7187  }
7188  },
7189 
7190  removeAttr: function( elem, value ) {
7191  var name, propName,
7192  i = 0,
7193  attrNames = value && value.match( rnotwhite );
7194 
7195  if ( attrNames && elem.nodeType === 1 ) {
7196  while ( ( name = attrNames[ i++ ] ) ) {
7197  propName = jQuery.propFix[ name ] || name;
7198 
7199  // Boolean attributes get special treatment (#10870)
7200  if ( jQuery.expr.match.bool.test( name ) ) {
7201 
7202  // Set corresponding property to false
7203  elem[ propName ] = false;
7204  }
7205 
7206  elem.removeAttribute( name );
7207  }
7208  }
7209  }
7210 } );
7211 
7212 // Hooks for boolean attributes
7213 boolHook = {
7214  set: function( elem, value, name ) {
7215  if ( value === false ) {
7216 
7217  // Remove boolean attributes when set to false
7218  jQuery.removeAttr( elem, name );
7219  } else {
7220  elem.setAttribute( name, name );
7221  }
7222  return name;
7223  }
7224 };
7225 jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
7226  var getter = attrHandle[ name ] || jQuery.find.attr;
7227 
7228  attrHandle[ name ] = function( elem, name, isXML ) {
7229  var ret, handle;
7230  if ( !isXML ) {
7231 
7232  // Avoid an infinite loop by temporarily removing this function from the getter
7233  handle = attrHandle[ name ];
7234  attrHandle[ name ] = ret;
7235  ret = getter( elem, name, isXML ) != null ?
7236  name.toLowerCase() :
7237  null;
7238  attrHandle[ name ] = handle;
7239  }
7240  return ret;
7241  };
7242 } );
7243 
7244 
7245 
7246 
7247 var rfocusable = /^(?:input|select|textarea|button)$/i,
7248  rclickable = /^(?:a|area)$/i;
7249 
7250 jQuery.fn.extend( {
7251  prop: function( name, value ) {
7252  return access( this, jQuery.prop, name, value, arguments.length > 1 );
7253  },
7254 
7255  removeProp: function( name ) {
7256  return this.each( function() {
7257  delete this[ jQuery.propFix[ name ] || name ];
7258  } );
7259  }
7260 } );
7261 
7262 jQuery.extend( {
7263  prop: function( elem, name, value ) {
7264  var ret, hooks,
7265  nType = elem.nodeType;
7266 
7267  // Don't get/set properties on text, comment and attribute nodes
7268  if ( nType === 3 || nType === 8 || nType === 2 ) {
7269  return;
7270  }
7271 
7272  if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7273 
7274  // Fix name and attach hooks
7275  name = jQuery.propFix[ name ] || name;
7276  hooks = jQuery.propHooks[ name ];
7277  }
7278 
7279  if ( value !== undefined ) {
7280  if ( hooks && "set" in hooks &&
7281  ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7282  return ret;
7283  }
7284 
7285  return ( elem[ name ] = value );
7286  }
7287 
7288  if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7289  return ret;
7290  }
7291 
7292  return elem[ name ];
7293  },
7294 
7295  propHooks: {
7296  tabIndex: {
7297  get: function( elem ) {
7298 
7299  // elem.tabIndex doesn't always return the
7300  // correct value when it hasn't been explicitly set
7301  // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
7302  // Use proper attribute retrieval(#12072)
7303  var tabindex = jQuery.find.attr( elem, "tabindex" );
7304 
7305  return tabindex ?
7306  parseInt( tabindex, 10 ) :
7307  rfocusable.test( elem.nodeName ) ||
7308  rclickable.test( elem.nodeName ) && elem.href ?
7309  0 :
7310  -1;
7311  }
7312  }
7313  },
7314 
7315  propFix: {
7316  "for": "htmlFor",
7317  "class": "className"
7318  }
7319 } );
7320 
7321 // Support: IE <=11 only
7322 // Accessing the selectedIndex property
7323 // forces the browser to respect setting selected
7324 // on the option
7325 // The getter ensures a default option is selected
7326 // when in an optgroup
7327 if ( !support.optSelected ) {
7328  jQuery.propHooks.selected = {
7329  get: function( elem ) {
7330  var parent = elem.parentNode;
7331  if ( parent && parent.parentNode ) {
7332  parent.parentNode.selectedIndex;
7333  }
7334  return null;
7335  },
7336  set: function( elem ) {
7337  var parent = elem.parentNode;
7338  if ( parent ) {
7339  parent.selectedIndex;
7340 
7341  if ( parent.parentNode ) {
7342  parent.parentNode.selectedIndex;
7343  }
7344  }
7345  }
7346  };
7347 }
7348 
7349 jQuery.each( [
7350  "tabIndex",
7351  "readOnly",
7352  "maxLength",
7353  "cellSpacing",
7354  "cellPadding",
7355  "rowSpan",
7356  "colSpan",
7357  "useMap",
7358  "frameBorder",
7359  "contentEditable"
7360 ], function() {
7361  jQuery.propFix[ this.toLowerCase() ] = this;
7362 } );
7363 
7364 
7365 
7366 
7367 var rclass = /[\t\r\n\f]/g;
7368 
7369 function getClass( elem ) {
7370  return elem.getAttribute && elem.getAttribute( "class" ) || "";
7371 }
7372 
7373 jQuery.fn.extend( {
7374  addClass: function( value ) {
7375  var classes, elem, cur, curValue, clazz, j, finalValue,
7376  i = 0;
7377 
7378  if ( jQuery.isFunction( value ) ) {
7379  return this.each( function( j ) {
7380  jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
7381  } );
7382  }
7383 
7384  if ( typeof value === "string" && value ) {
7385  classes = value.match( rnotwhite ) || [];
7386 
7387  while ( ( elem = this[ i++ ] ) ) {
7388  curValue = getClass( elem );
7389  cur = elem.nodeType === 1 &&
7390  ( " " + curValue + " " ).replace( rclass, " " );
7391 
7392  if ( cur ) {
7393  j = 0;
7394  while ( ( clazz = classes[ j++ ] ) ) {
7395  if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
7396  cur += clazz + " ";
7397  }
7398  }
7399 
7400  // Only assign if different to avoid unneeded rendering.
7401  finalValue = jQuery.trim( cur );
7402  if ( curValue !== finalValue ) {
7403  elem.setAttribute( "class", finalValue );
7404  }
7405  }
7406  }
7407  }
7408 
7409  return this;
7410  },
7411 
7412  removeClass: function( value ) {
7413  var classes, elem, cur, curValue, clazz, j, finalValue,
7414  i = 0;
7415 
7416  if ( jQuery.isFunction( value ) ) {
7417  return this.each( function( j ) {
7418  jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
7419  } );
7420  }
7421 
7422  if ( !arguments.length ) {
7423  return this.attr( "class", "" );
7424  }
7425 
7426  if ( typeof value === "string" && value ) {
7427  classes = value.match( rnotwhite ) || [];
7428 
7429  while ( ( elem = this[ i++ ] ) ) {
7430  curValue = getClass( elem );
7431 
7432  // This expression is here for better compressibility (see addClass)
7433  cur = elem.nodeType === 1 &&
7434  ( " " + curValue + " " ).replace( rclass, " " );
7435 
7436  if ( cur ) {
7437  j = 0;
7438  while ( ( clazz = classes[ j++ ] ) ) {
7439 
7440  // Remove *all* instances
7441  while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
7442  cur = cur.replace( " " + clazz + " ", " " );
7443  }
7444  }
7445 
7446  // Only assign if different to avoid unneeded rendering.
7447  finalValue = jQuery.trim( cur );
7448  if ( curValue !== finalValue ) {
7449  elem.setAttribute( "class", finalValue );
7450  }
7451  }
7452  }
7453  }
7454 
7455  return this;
7456  },
7457 
7458  toggleClass: function( value, stateVal ) {
7459  var type = typeof value;
7460 
7461  if ( typeof stateVal === "boolean" && type === "string" ) {
7462  return stateVal ? this.addClass( value ) : this.removeClass( value );
7463  }
7464 
7465  if ( jQuery.isFunction( value ) ) {
7466  return this.each( function( i ) {
7467  jQuery( this ).toggleClass(
7468  value.call( this, i, getClass( this ), stateVal ),
7469  stateVal
7470  );
7471  } );
7472  }
7473 
7474  return this.each( function() {
7475  var className, i, self, classNames;
7476 
7477  if ( type === "string" ) {
7478 
7479  // Toggle individual class names
7480  i = 0;
7481  self = jQuery( this );
7482  classNames = value.match( rnotwhite ) || [];
7483 
7484  while ( ( className = classNames[ i++ ] ) ) {
7485 
7486  // Check each className given, space separated list
7487  if ( self.hasClass( className ) ) {
7488  self.removeClass( className );
7489  } else {
7490  self.addClass( className );
7491  }
7492  }
7493 
7494  // Toggle whole class name
7495  } else if ( value === undefined || type === "boolean" ) {
7496  className = getClass( this );
7497  if ( className ) {
7498 
7499  // Store className if set
7500  dataPriv.set( this, "__className__", className );
7501  }
7502 
7503  // If the element has a class name or if we're passed `false`,
7504  // then remove the whole classname (if there was one, the above saved it).
7505  // Otherwise bring back whatever was previously saved (if anything),
7506  // falling back to the empty string if nothing was stored.
7507  if ( this.setAttribute ) {
7508  this.setAttribute( "class",
7509  className || value === false ?
7510  "" :
7511  dataPriv.get( this, "__className__" ) || ""
7512  );
7513  }
7514  }
7515  } );
7516  },
7517 
7518  hasClass: function( selector ) {
7519  var className, elem,
7520  i = 0;
7521 
7522  className = " " + selector + " ";
7523  while ( ( elem = this[ i++ ] ) ) {
7524  if ( elem.nodeType === 1 &&
7525  ( " " + getClass( elem ) + " " ).replace( rclass, " " )
7526  .indexOf( className ) > -1
7527  ) {
7528  return true;
7529  }
7530  }
7531 
7532  return false;
7533  }
7534 } );
7535 
7536 
7537 
7538 
7539 var rreturn = /\r/g,
7540  rspaces = /[\x20\t\r\n\f]+/g;
7541 
7542 jQuery.fn.extend( {
7543  val: function( value ) {
7544  var hooks, ret, isFunction,
7545  elem = this[ 0 ];
7546 
7547  if ( !arguments.length ) {
7548  if ( elem ) {
7549  hooks = jQuery.valHooks[ elem.type ] ||
7550  jQuery.valHooks[ elem.nodeName.toLowerCase() ];
7551 
7552  if ( hooks &&
7553  "get" in hooks &&
7554  ( ret = hooks.get( elem, "value" ) ) !== undefined
7555  ) {
7556  return ret;
7557  }
7558 
7559  ret = elem.value;
7560 
7561  return typeof ret === "string" ?
7562 
7563  // Handle most common string cases
7564  ret.replace( rreturn, "" ) :
7565 
7566  // Handle cases where value is null/undef or number
7567  ret == null ? "" : ret;
7568  }
7569 
7570  return;
7571  }
7572 
7573  isFunction = jQuery.isFunction( value );
7574 
7575  return this.each( function( i ) {
7576  var val;
7577 
7578  if ( this.nodeType !== 1 ) {
7579  return;
7580  }
7581 
7582  if ( isFunction ) {
7583  val = value.call( this, i, jQuery( this ).val() );
7584  } else {
7585  val = value;
7586  }
7587 
7588  // Treat null/undefined as ""; convert numbers to string
7589  if ( val == null ) {
7590  val = "";
7591 
7592  } else if ( typeof val === "number" ) {
7593  val += "";
7594 
7595  } else if ( jQuery.isArray( val ) ) {
7596  val = jQuery.map( val, function( value ) {
7597  return value == null ? "" : value + "";
7598  } );
7599  }
7600 
7601  hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
7602 
7603  // If set returns undefined, fall back to normal setting
7604  if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
7605  this.value = val;
7606  }
7607  } );
7608  }
7609 } );
7610 
7611 jQuery.extend( {
7612  valHooks: {
7613  option: {
7614  get: function( elem ) {
7615 
7616  var val = jQuery.find.attr( elem, "value" );
7617  return val != null ?
7618  val :
7619 
7620  // Support: IE10-11+
7621  // option.text throws exceptions (#14686, #14858)
7622  // Strip and collapse whitespace
7623  // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
7624  jQuery.trim( jQuery.text( elem ) ).replace( rspaces, " " );
7625  }
7626  },
7627  select: {
7628  get: function( elem ) {
7629  var value, option,
7630  options = elem.options,
7631  index = elem.selectedIndex,
7632  one = elem.type === "select-one" || index < 0,
7633  values = one ? null : [],
7634  max = one ? index + 1 : options.length,
7635  i = index < 0 ?
7636  max :
7637  one ? index : 0;
7638 
7639  // Loop through all the selected options
7640  for ( ; i < max; i++ ) {
7641  option = options[ i ];
7642 
7643  // IE8-9 doesn't update selected after form reset (#2551)
7644  if ( ( option.selected || i === index ) &&
7645 
7646  // Don't return options that are disabled or in a disabled optgroup
7647  ( support.optDisabled ?
7648  !option.disabled : option.getAttribute( "disabled" ) === null ) &&
7649  ( !option.parentNode.disabled ||
7650  !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
7651 
7652  // Get the specific value for the option
7653  value = jQuery( option ).val();
7654 
7655  // We don't need an array for one selects
7656  if ( one ) {
7657  return value;
7658  }
7659 
7660  // Multi-Selects return an array
7661  values.push( value );
7662  }
7663  }
7664 
7665  return values;
7666  },
7667 
7668  set: function( elem, value ) {
7669  var optionSet, option,
7670  options = elem.options,
7671  values = jQuery.makeArray( value ),
7672  i = options.length;
7673 
7674  while ( i-- ) {
7675  option = options[ i ];
7676  if ( option.selected =
7677  jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
7678  ) {
7679  optionSet = true;
7680  }
7681  }
7682 
7683  // Force browsers to behave consistently when non-matching value is set
7684  if ( !optionSet ) {
7685  elem.selectedIndex = -1;
7686  }
7687  return values;
7688  }
7689  }
7690  }
7691 } );
7692 
7693 // Radios and checkboxes getter/setter
7694 jQuery.each( [ "radio", "checkbox" ], function() {
7695  jQuery.valHooks[ this ] = {
7696  set: function( elem, value ) {
7697  if ( jQuery.isArray( value ) ) {
7698  return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );