· 8 years ago · Apr 07, 2018, 09:28 AM
1/*!
2 * jQuery JavaScript Library v3.2.1
3 * https://jquery.com/
4 *
5 * Includes Sizzle.js
6 * https://sizzlejs.com/
7 *
8 * Copyright JS Foundation and other contributors
9 * Released under the MIT license
10 * https://jquery.org/license
11 *
12 * Date: 2017-03-20T18:59Z
13 */
14( function( global, factory ) {
15
16 "use strict";
17
18 if ( typeof module === "object" && typeof module.exports === "object" ) {
19
20 // For CommonJS and CommonJS-like environments where a proper `window`
21 // is present, execute the factory and get jQuery.
22 // For environments that do not have a `window` with a `document`
23 // (such as Node.js), expose a factory as module.exports.
24 // This accentuates the need for the creation of a real `window`.
25 // e.g. var jQuery = require("jquery")(window);
26 // See ticket #14549 for more info.
27 module.exports = global.document ?
28 factory( global, true ) :
29 function( w ) {
30 if ( !w.document ) {
31 throw new Error( "jQuery requires a window with a document" );
32 }
33 return factory( w );
34 };
35 } else {
36 factory( global );
37 }
38
39// Pass this if window is not defined yet
40} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
41
42// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
43// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
44// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
45// enough that all such attempts are guarded in a try block.
46"use strict";
47
48var arr = [];
49
50var document = window.document;
51
52var getProto = Object.getPrototypeOf;
53
54var slice = arr.slice;
55
56var concat = arr.concat;
57
58var push = arr.push;
59
60var indexOf = arr.indexOf;
61
62var class2type = {};
63
64var toString = class2type.toString;
65
66var hasOwn = class2type.hasOwnProperty;
67
68var fnToString = hasOwn.toString;
69
70var ObjectFunctionString = fnToString.call( Object );
71
72var support = {};
73
74
75
76 function DOMEval( code, doc ) {
77 doc = doc || document;
78
79 var script = doc.createElement( "script" );
80
81 script.text = code;
82 doc.head.appendChild( script ).parentNode.removeChild( script );
83 }
84/* global Symbol */
85// Defining this global in .eslintrc.json would create a danger of using the global
86// unguarded in another place, it seems safer to define global only for this module
87
88
89
90var
91 version = "3.2.1",
92
93 // Define a local copy of jQuery
94 jQuery = function( selector, context ) {
95
96 // The jQuery object is actually just the init constructor 'enhanced'
97 // Need init if jQuery is called (just allow error to be thrown if not included)
98 return new jQuery.fn.init( selector, context );
99 },
100
101 // Support: Android <=4.0 only
102 // Make sure we trim BOM and NBSP
103 rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
104
105 // Matches dashed string for camelizing
106 rmsPrefix = /^-ms-/,
107 rdashAlpha = /-([a-z])/g,
108
109 // Used by jQuery.camelCase as callback to replace()
110 fcamelCase = function( all, letter ) {
111 return letter.toUpperCase();
112 };
113
114jQuery.fn = jQuery.prototype = {
115
116 // The current version of jQuery being used
117 jquery: version,
118
119 constructor: jQuery,
120
121 // The default length of a jQuery object is 0
122 length: 0,
123
124 toArray: function() {
125 return slice.call( this );
126 },
127
128 // Get the Nth element in the matched element set OR
129 // Get the whole matched element set as a clean array
130 get: function( num ) {
131
132 // Return all the elements in a clean array
133 if ( num == null ) {
134 return slice.call( this );
135 }
136
137 // Return just the one element from the set
138 return num < 0 ? this[ num + this.length ] : this[ num ];
139 },
140
141 // Take an array of elements and push it onto the stack
142 // (returning the new matched element set)
143 pushStack: function( elems ) {
144
145 // Build a new jQuery matched element set
146 var ret = jQuery.merge( this.constructor(), elems );
147
148 // Add the old object onto the stack (as a reference)
149 ret.prevObject = this;
150
151 // Return the newly-formed element set
152 return ret;
153 },
154
155 // Execute a callback for every element in the matched set.
156 each: function( callback ) {
157 return jQuery.each( this, callback );
158 },
159
160 map: function( callback ) {
161 return this.pushStack( jQuery.map( this, function( elem, i ) {
162 return callback.call( elem, i, elem );
163 } ) );
164 },
165
166 slice: function() {
167 return this.pushStack( slice.apply( this, arguments ) );
168 },
169
170 first: function() {
171 return this.eq( 0 );
172 },
173
174 last: function() {
175 return this.eq( -1 );
176 },
177
178 eq: function( i ) {
179 var len = this.length,
180 j = +i + ( i < 0 ? len : 0 );
181 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
182 },
183
184 end: function() {
185 return this.prevObject || this.constructor();
186 },
187
188 // For internal use only.
189 // Behaves like an Array's method, not like a jQuery method.
190 push: push,
191 sort: arr.sort,
192 splice: arr.splice
193};
194
195jQuery.extend = jQuery.fn.extend = function() {
196 var options, name, src, copy, copyIsArray, clone,
197 target = arguments[ 0 ] || {},
198 i = 1,
199 length = arguments.length,
200 deep = false;
201
202 // Handle a deep copy situation
203 if ( typeof target === "boolean" ) {
204 deep = target;
205
206 // Skip the boolean and the target
207 target = arguments[ i ] || {};
208 i++;
209 }
210
211 // Handle case when target is a string or something (possible in deep copy)
212 if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
213 target = {};
214 }
215
216 // Extend jQuery itself if only one argument is passed
217 if ( i === length ) {
218 target = this;
219 i--;
220 }
221
222 for ( ; i < length; i++ ) {
223
224 // Only deal with non-null/undefined values
225 if ( ( options = arguments[ i ] ) != null ) {
226
227 // Extend the base object
228 for ( name in options ) {
229 src = target[ name ];
230 copy = options[ name ];
231
232 // Prevent never-ending loop
233 if ( target === copy ) {
234 continue;
235 }
236
237 // Recurse if we're merging plain objects or arrays
238 if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
239 ( copyIsArray = Array.isArray( copy ) ) ) ) {
240
241 if ( copyIsArray ) {
242 copyIsArray = false;
243 clone = src && Array.isArray( src ) ? src : [];
244
245 } else {
246 clone = src && jQuery.isPlainObject( src ) ? src : {};
247 }
248
249 // Never move original objects, clone them
250 target[ name ] = jQuery.extend( deep, clone, copy );
251
252 // Don't bring in undefined values
253 } else if ( copy !== undefined ) {
254 target[ name ] = copy;
255 }
256 }
257 }
258 }
259
260 // Return the modified object
261 return target;
262};
263
264jQuery.extend( {
265
266 // Unique for each copy of jQuery on the page
267 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
268
269 // Assume jQuery is ready without the ready module
270 isReady: true,
271
272 error: function( msg ) {
273 throw new Error( msg );
274 },
275
276 noop: function() {},
277
278 isFunction: function( obj ) {
279 return jQuery.type( obj ) === "function";
280 },
281
282 isWindow: function( obj ) {
283 return obj != null && obj === obj.window;
284 },
285
286 isNumeric: function( obj ) {
287
288 // As of jQuery 3.0, isNumeric is limited to
289 // strings and numbers (primitives or objects)
290 // that can be coerced to finite numbers (gh-2662)
291 var type = jQuery.type( obj );
292 return ( type === "number" || type === "string" ) &&
293
294 // parseFloat NaNs numeric-cast false positives ("")
295 // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
296 // subtraction forces infinities to NaN
297 !isNaN( obj - parseFloat( obj ) );
298 },
299
300 isPlainObject: function( obj ) {
301 var proto, Ctor;
302
303 // Detect obvious negatives
304 // Use toString instead of jQuery.type to catch host objects
305 if ( !obj || toString.call( obj ) !== "[object Object]" ) {
306 return false;
307 }
308
309 proto = getProto( obj );
310
311 // Objects with no prototype (e.g., `Object.create( null )`) are plain
312 if ( !proto ) {
313 return true;
314 }
315
316 // Objects with prototype are plain iff they were constructed by a global Object function
317 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
318 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
319 },
320
321 isEmptyObject: function( obj ) {
322
323 /* eslint-disable no-unused-vars */
324 // See https://github.com/eslint/eslint/issues/6125
325 var name;
326
327 for ( name in obj ) {
328 return false;
329 }
330 return true;
331 },
332
333 type: function( obj ) {
334 if ( obj == null ) {
335 return obj + "";
336 }
337
338 // Support: Android <=2.3 only (functionish RegExp)
339 return typeof obj === "object" || typeof obj === "function" ?
340 class2type[ toString.call( obj ) ] || "object" :
341 typeof obj;
342 },
343
344 // Evaluates a script in a global context
345 globalEval: function( code ) {
346 DOMEval( code );
347 },
348
349 // Convert dashed to camelCase; used by the css and data modules
350 // Support: IE <=9 - 11, Edge 12 - 13
351 // Microsoft forgot to hump their vendor prefix (#9572)
352 camelCase: function( string ) {
353 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
354 },
355
356 each: function( obj, callback ) {
357 var length, i = 0;
358
359 if ( isArrayLike( obj ) ) {
360 length = obj.length;
361 for ( ; i < length; i++ ) {
362 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
363 break;
364 }
365 }
366 } else {
367 for ( i in obj ) {
368 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
369 break;
370 }
371 }
372 }
373
374 return obj;
375 },
376
377 // Support: Android <=4.0 only
378 trim: function( text ) {
379 return text == null ?
380 "" :
381 ( text + "" ).replace( rtrim, "" );
382 },
383
384 // results is for internal usage only
385 makeArray: function( arr, results ) {
386 var ret = results || [];
387
388 if ( arr != null ) {
389 if ( isArrayLike( Object( arr ) ) ) {
390 jQuery.merge( ret,
391 typeof arr === "string" ?
392 [ arr ] : arr
393 );
394 } else {
395 push.call( ret, arr );
396 }
397 }
398
399 return ret;
400 },
401
402 inArray: function( elem, arr, i ) {
403 return arr == null ? -1 : indexOf.call( arr, elem, i );
404 },
405
406 // Support: Android <=4.0 only, PhantomJS 1 only
407 // push.apply(_, arraylike) throws on ancient WebKit
408 merge: function( first, second ) {
409 var len = +second.length,
410 j = 0,
411 i = first.length;
412
413 for ( ; j < len; j++ ) {
414 first[ i++ ] = second[ j ];
415 }
416
417 first.length = i;
418
419 return first;
420 },
421
422 grep: function( elems, callback, invert ) {
423 var callbackInverse,
424 matches = [],
425 i = 0,
426 length = elems.length,
427 callbackExpect = !invert;
428
429 // Go through the array, only saving the items
430 // that pass the validator function
431 for ( ; i < length; i++ ) {
432 callbackInverse = !callback( elems[ i ], i );
433 if ( callbackInverse !== callbackExpect ) {
434 matches.push( elems[ i ] );
435 }
436 }
437
438 return matches;
439 },
440
441 // arg is for internal usage only
442 map: function( elems, callback, arg ) {
443 var length, value,
444 i = 0,
445 ret = [];
446
447 // Go through the array, translating each of the items to their new values
448 if ( isArrayLike( elems ) ) {
449 length = elems.length;
450 for ( ; i < length; i++ ) {
451 value = callback( elems[ i ], i, arg );
452
453 if ( value != null ) {
454 ret.push( value );
455 }
456 }
457
458 // Go through every key on the object,
459 } else {
460 for ( i in elems ) {
461 value = callback( elems[ i ], i, arg );
462
463 if ( value != null ) {
464 ret.push( value );
465 }
466 }
467 }
468
469 // Flatten any nested arrays
470 return concat.apply( [], ret );
471 },
472
473 // A global GUID counter for objects
474 guid: 1,
475
476 // Bind a function to a context, optionally partially applying any
477 // arguments.
478 proxy: function( fn, context ) {
479 var tmp, args, proxy;
480
481 if ( typeof context === "string" ) {
482 tmp = fn[ context ];
483 context = fn;
484 fn = tmp;
485 }
486
487 // Quick check to determine if target is callable, in the spec
488 // this throws a TypeError, but we will just return undefined.
489 if ( !jQuery.isFunction( fn ) ) {
490 return undefined;
491 }
492
493 // Simulated bind
494 args = slice.call( arguments, 2 );
495 proxy = function() {
496 return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
497 };
498
499 // Set the guid of unique handler to the same of original handler, so it can be removed
500 proxy.guid = fn.guid = fn.guid || jQuery.guid++;
501
502 return proxy;
503 },
504
505 now: Date.now,
506
507 // jQuery.support is not used in Core but other projects attach their
508 // properties to it so it needs to exist.
509 support: support
510} );
511
512if ( typeof Symbol === "function" ) {
513 jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
514}
515
516// Populate the class2type map
517jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
518function( i, name ) {
519 class2type[ "[object " + name + "]" ] = name.toLowerCase();
520} );
521
522function isArrayLike( obj ) {
523
524 // Support: real iOS 8.2 only (not reproducible in simulator)
525 // `in` check used to prevent JIT error (gh-2145)
526 // hasOwn isn't used here due to false negatives
527 // regarding Nodelist length in IE
528 var length = !!obj && "length" in obj && obj.length,
529 type = jQuery.type( obj );
530
531 if ( type === "function" || jQuery.isWindow( obj ) ) {
532 return false;
533 }
534
535 return type === "array" || length === 0 ||
536 typeof length === "number" && length > 0 && ( length - 1 ) in obj;
537}
538var Sizzle =
539/*!
540 * Sizzle CSS Selector Engine v2.3.3
541 * https://sizzlejs.com/
542 *
543 * Copyright jQuery Foundation and other contributors
544 * Released under the MIT license
545 * http://jquery.org/license
546 *
547 * Date: 2016-08-08
548 */
549(function( window ) {
550
551var i,
552 support,
553 Expr,
554 getText,
555 isXML,
556 tokenize,
557 compile,
558 select,
559 outermostContext,
560 sortInput,
561 hasDuplicate,
562
563 // Local document vars
564 setDocument,
565 document,
566 docElem,
567 documentIsHTML,
568 rbuggyQSA,
569 rbuggyMatches,
570 matches,
571 contains,
572
573 // Instance-specific data
574 expando = "sizzle" + 1 * new Date(),
575 preferredDoc = window.document,
576 dirruns = 0,
577 done = 0,
578 classCache = createCache(),
579 tokenCache = createCache(),
580 compilerCache = createCache(),
581 sortOrder = function( a, b ) {
582 if ( a === b ) {
583 hasDuplicate = true;
584 }
585 return 0;
586 },
587
588 // Instance methods
589 hasOwn = ({}).hasOwnProperty,
590 arr = [],
591 pop = arr.pop,
592 push_native = arr.push,
593 push = arr.push,
594 slice = arr.slice,
595 // Use a stripped-down indexOf as it's faster than native
596 // https://jsperf.com/thor-indexof-vs-for/5
597 indexOf = function( list, elem ) {
598 var i = 0,
599 len = list.length;
600 for ( ; i < len; i++ ) {
601 if ( list[i] === elem ) {
602 return i;
603 }
604 }
605 return -1;
606 },
607
608 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
609
610 // Regular expressions
611
612 // http://www.w3.org/TR/css3-selectors/#whitespace
613 whitespace = "[\\x20\\t\\r\\n\\f]",
614
615 // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
616 identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
617
618 // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
619 attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
620 // Operator (capture 2)
621 "*([*^$|!~]?=)" + whitespace +
622 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
623 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
624 "*\\]",
625
626 pseudos = ":(" + identifier + ")(?:\\((" +
627 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
628 // 1. quoted (capture 3; capture 4 or capture 5)
629 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
630 // 2. simple (capture 6)
631 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
632 // 3. anything else (capture 2)
633 ".*" +
634 ")\\)|)",
635
636 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
637 rwhitespace = new RegExp( whitespace + "+", "g" ),
638 rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
639
640 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
641 rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
642
643 rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
644
645 rpseudo = new RegExp( pseudos ),
646 ridentifier = new RegExp( "^" + identifier + "$" ),
647
648 matchExpr = {
649 "ID": new RegExp( "^#(" + identifier + ")" ),
650 "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
651 "TAG": new RegExp( "^(" + identifier + "|[*])" ),
652 "ATTR": new RegExp( "^" + attributes ),
653 "PSEUDO": new RegExp( "^" + pseudos ),
654 "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
655 "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
656 "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
657 "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
658 // For use in libraries implementing .is()
659 // We use this for POS matching in `select`
660 "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
661 whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
662 },
663
664 rinputs = /^(?:input|select|textarea|button)$/i,
665 rheader = /^h\d$/i,
666
667 rnative = /^[^{]+\{\s*\[native \w/,
668
669 // Easily-parseable/retrievable ID or TAG or CLASS selectors
670 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
671
672 rsibling = /[+~]/,
673
674 // CSS escapes
675 // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
676 runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
677 funescape = function( _, escaped, escapedWhitespace ) {
678 var high = "0x" + escaped - 0x10000;
679 // NaN means non-codepoint
680 // Support: Firefox<24
681 // Workaround erroneous numeric interpretation of +"0x"
682 return high !== high || escapedWhitespace ?
683 escaped :
684 high < 0 ?
685 // BMP codepoint
686 String.fromCharCode( high + 0x10000 ) :
687 // Supplemental Plane codepoint (surrogate pair)
688 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
689 },
690
691 // CSS string/identifier serialization
692 // https://drafts.csswg.org/cssom/#common-serializing-idioms
693 rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
694 fcssescape = function( ch, asCodePoint ) {
695 if ( asCodePoint ) {
696
697 // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
698 if ( ch === "\0" ) {
699 return "\uFFFD";
700 }
701
702 // Control characters and (dependent upon position) numbers get escaped as code points
703 return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
704 }
705
706 // Other potentially-special ASCII characters get backslash-escaped
707 return "\\" + ch;
708 },
709
710 // Used for iframes
711 // See setDocument()
712 // Removing the function wrapper causes a "Permission Denied"
713 // error in IE
714 unloadHandler = function() {
715 setDocument();
716 },
717
718 disabledAncestor = addCombinator(
719 function( elem ) {
720 return elem.disabled === true && ("form" in elem || "label" in elem);
721 },
722 { dir: "parentNode", next: "legend" }
723 );
724
725// Optimize for push.apply( _, NodeList )
726try {
727 push.apply(
728 (arr = slice.call( preferredDoc.childNodes )),
729 preferredDoc.childNodes
730 );
731 // Support: Android<4.0
732 // Detect silently failing push.apply
733 arr[ preferredDoc.childNodes.length ].nodeType;
734} catch ( e ) {
735 push = { apply: arr.length ?
736
737 // Leverage slice if possible
738 function( target, els ) {
739 push_native.apply( target, slice.call(els) );
740 } :
741
742 // Support: IE<9
743 // Otherwise append directly
744 function( target, els ) {
745 var j = target.length,
746 i = 0;
747 // Can't trust NodeList.length
748 while ( (target[j++] = els[i++]) ) {}
749 target.length = j - 1;
750 }
751 };
752}
753
754function Sizzle( selector, context, results, seed ) {
755 var m, i, elem, nid, match, groups, newSelector,
756 newContext = context && context.ownerDocument,
757
758 // nodeType defaults to 9, since context defaults to document
759 nodeType = context ? context.nodeType : 9;
760
761 results = results || [];
762
763 // Return early from calls with invalid selector or context
764 if ( typeof selector !== "string" || !selector ||
765 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
766
767 return results;
768 }
769
770 // Try to shortcut find operations (as opposed to filters) in HTML documents
771 if ( !seed ) {
772
773 if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
774 setDocument( context );
775 }
776 context = context || document;
777
778 if ( documentIsHTML ) {
779
780 // If the selector is sufficiently simple, try using a "get*By*" DOM method
781 // (excepting DocumentFragment context, where the methods don't exist)
782 if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
783
784 // ID selector
785 if ( (m = match[1]) ) {
786
787 // Document context
788 if ( nodeType === 9 ) {
789 if ( (elem = context.getElementById( m )) ) {
790
791 // Support: IE, Opera, Webkit
792 // TODO: identify versions
793 // getElementById can match elements by name instead of ID
794 if ( elem.id === m ) {
795 results.push( elem );
796 return results;
797 }
798 } else {
799 return results;
800 }
801
802 // Element context
803 } else {
804
805 // Support: IE, Opera, Webkit
806 // TODO: identify versions
807 // getElementById can match elements by name instead of ID
808 if ( newContext && (elem = newContext.getElementById( m )) &&
809 contains( context, elem ) &&
810 elem.id === m ) {
811
812 results.push( elem );
813 return results;
814 }
815 }
816
817 // Type selector
818 } else if ( match[2] ) {
819 push.apply( results, context.getElementsByTagName( selector ) );
820 return results;
821
822 // Class selector
823 } else if ( (m = match[3]) && support.getElementsByClassName &&
824 context.getElementsByClassName ) {
825
826 push.apply( results, context.getElementsByClassName( m ) );
827 return results;
828 }
829 }
830
831 // Take advantage of querySelectorAll
832 if ( support.qsa &&
833 !compilerCache[ selector + " " ] &&
834 (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
835
836 if ( nodeType !== 1 ) {
837 newContext = context;
838 newSelector = selector;
839
840 // qSA looks outside Element context, which is not what we want
841 // Thanks to Andrew Dupont for this workaround technique
842 // Support: IE <=8
843 // Exclude object elements
844 } else if ( context.nodeName.toLowerCase() !== "object" ) {
845
846 // Capture the context ID, setting it first if necessary
847 if ( (nid = context.getAttribute( "id" )) ) {
848 nid = nid.replace( rcssescape, fcssescape );
849 } else {
850 context.setAttribute( "id", (nid = expando) );
851 }
852
853 // Prefix every selector in the list
854 groups = tokenize( selector );
855 i = groups.length;
856 while ( i-- ) {
857 groups[i] = "#" + nid + " " + toSelector( groups[i] );
858 }
859 newSelector = groups.join( "," );
860
861 // Expand context for sibling selectors
862 newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
863 context;
864 }
865
866 if ( newSelector ) {
867 try {
868 push.apply( results,
869 newContext.querySelectorAll( newSelector )
870 );
871 return results;
872 } catch ( qsaError ) {
873 } finally {
874 if ( nid === expando ) {
875 context.removeAttribute( "id" );
876 }
877 }
878 }
879 }
880 }
881 }
882
883 // All others
884 return select( selector.replace( rtrim, "$1" ), context, results, seed );
885}
886
887/**
888 * Create key-value caches of limited size
889 * @returns {function(string, object)} Returns the Object data after storing it on itself with
890 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
891 * deleting the oldest entry
892 */
893function createCache() {
894 var keys = [];
895
896 function cache( key, value ) {
897 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
898 if ( keys.push( key + " " ) > Expr.cacheLength ) {
899 // Only keep the most recent entries
900 delete cache[ keys.shift() ];
901 }
902 return (cache[ key + " " ] = value);
903 }
904 return cache;
905}
906
907/**
908 * Mark a function for special use by Sizzle
909 * @param {Function} fn The function to mark
910 */
911function markFunction( fn ) {
912 fn[ expando ] = true;
913 return fn;
914}
915
916/**
917 * Support testing using an element
918 * @param {Function} fn Passed the created element and returns a boolean result
919 */
920function assert( fn ) {
921 var el = document.createElement("fieldset");
922
923 try {
924 return !!fn( el );
925 } catch (e) {
926 return false;
927 } finally {
928 // Remove from its parent by default
929 if ( el.parentNode ) {
930 el.parentNode.removeChild( el );
931 }
932 // release memory in IE
933 el = null;
934 }
935}
936
937/**
938 * Adds the same handler for all of the specified attrs
939 * @param {String} attrs Pipe-separated list of attributes
940 * @param {Function} handler The method that will be applied
941 */
942function addHandle( attrs, handler ) {
943 var arr = attrs.split("|"),
944 i = arr.length;
945
946 while ( i-- ) {
947 Expr.attrHandle[ arr[i] ] = handler;
948 }
949}
950
951/**
952 * Checks document order of two siblings
953 * @param {Element} a
954 * @param {Element} b
955 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
956 */
957function siblingCheck( a, b ) {
958 var cur = b && a,
959 diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
960 a.sourceIndex - b.sourceIndex;
961
962 // Use IE sourceIndex if available on both nodes
963 if ( diff ) {
964 return diff;
965 }
966
967 // Check if b follows a
968 if ( cur ) {
969 while ( (cur = cur.nextSibling) ) {
970 if ( cur === b ) {
971 return -1;
972 }
973 }
974 }
975
976 return a ? 1 : -1;
977}
978
979/**
980 * Returns a function to use in pseudos for input types
981 * @param {String} type
982 */
983function createInputPseudo( type ) {
984 return function( elem ) {
985 var name = elem.nodeName.toLowerCase();
986 return name === "input" && elem.type === type;
987 };
988}
989
990/**
991 * Returns a function to use in pseudos for buttons
992 * @param {String} type
993 */
994function createButtonPseudo( type ) {
995 return function( elem ) {
996 var name = elem.nodeName.toLowerCase();
997 return (name === "input" || name === "button") && elem.type === type;
998 };
999}
1000
1001/**
1002 * Returns a function to use in pseudos for :enabled/:disabled
1003 * @param {Boolean} disabled true for :disabled; false for :enabled
1004 */
1005function createDisabledPseudo( disabled ) {
1006
1007 // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1008 return function( elem ) {
1009
1010 // Only certain elements can match :enabled or :disabled
1011 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1012 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1013 if ( "form" in elem ) {
1014
1015 // Check for inherited disabledness on relevant non-disabled elements:
1016 // * listed form-associated elements in a disabled fieldset
1017 // https://html.spec.whatwg.org/multipage/forms.html#category-listed
1018 // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1019 // * option elements in a disabled optgroup
1020 // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1021 // All such elements have a "form" property.
1022 if ( elem.parentNode && elem.disabled === false ) {
1023
1024 // Option elements defer to a parent optgroup if present
1025 if ( "label" in elem ) {
1026 if ( "label" in elem.parentNode ) {
1027 return elem.parentNode.disabled === disabled;
1028 } else {
1029 return elem.disabled === disabled;
1030 }
1031 }
1032
1033 // Support: IE 6 - 11
1034 // Use the isDisabled shortcut property to check for disabled fieldset ancestors
1035 return elem.isDisabled === disabled ||
1036
1037 // Where there is no isDisabled, check manually
1038 /* jshint -W018 */
1039 elem.isDisabled !== !disabled &&
1040 disabledAncestor( elem ) === disabled;
1041 }
1042
1043 return elem.disabled === disabled;
1044
1045 // Try to winnow out elements that can't be disabled before trusting the disabled property.
1046 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1047 // even exist on them, let alone have a boolean value.
1048 } else if ( "label" in elem ) {
1049 return elem.disabled === disabled;
1050 }
1051
1052 // Remaining elements are neither :enabled nor :disabled
1053 return false;
1054 };
1055}
1056
1057/**
1058 * Returns a function to use in pseudos for positionals
1059 * @param {Function} fn
1060 */
1061function createPositionalPseudo( fn ) {
1062 return markFunction(function( argument ) {
1063 argument = +argument;
1064 return markFunction(function( seed, matches ) {
1065 var j,
1066 matchIndexes = fn( [], seed.length, argument ),
1067 i = matchIndexes.length;
1068
1069 // Match elements found at the specified indexes
1070 while ( i-- ) {
1071 if ( seed[ (j = matchIndexes[i]) ] ) {
1072 seed[j] = !(matches[j] = seed[j]);
1073 }
1074 }
1075 });
1076 });
1077}
1078
1079/**
1080 * Checks a node for validity as a Sizzle context
1081 * @param {Element|Object=} context
1082 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1083 */
1084function testContext( context ) {
1085 return context && typeof context.getElementsByTagName !== "undefined" && context;
1086}
1087
1088// Expose support vars for convenience
1089support = Sizzle.support = {};
1090
1091/**
1092 * Detects XML nodes
1093 * @param {Element|Object} elem An element or a document
1094 * @returns {Boolean} True iff elem is a non-HTML XML node
1095 */
1096isXML = Sizzle.isXML = function( elem ) {
1097 // documentElement is verified for cases where it doesn't yet exist
1098 // (such as loading iframes in IE - #4833)
1099 var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1100 return documentElement ? documentElement.nodeName !== "HTML" : false;
1101};
1102
1103/**
1104 * Sets document-related variables once based on the current document
1105 * @param {Element|Object} [doc] An element or document object to use to set the document
1106 * @returns {Object} Returns the current document
1107 */
1108setDocument = Sizzle.setDocument = function( node ) {
1109 var hasCompare, subWindow,
1110 doc = node ? node.ownerDocument || node : preferredDoc;
1111
1112 // Return early if doc is invalid or already selected
1113 if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1114 return document;
1115 }
1116
1117 // Update global variables
1118 document = doc;
1119 docElem = document.documentElement;
1120 documentIsHTML = !isXML( document );
1121
1122 // Support: IE 9-11, Edge
1123 // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1124 if ( preferredDoc !== document &&
1125 (subWindow = document.defaultView) && subWindow.top !== subWindow ) {
1126
1127 // Support: IE 11, Edge
1128 if ( subWindow.addEventListener ) {
1129 subWindow.addEventListener( "unload", unloadHandler, false );
1130
1131 // Support: IE 9 - 10 only
1132 } else if ( subWindow.attachEvent ) {
1133 subWindow.attachEvent( "onunload", unloadHandler );
1134 }
1135 }
1136
1137 /* Attributes
1138 ---------------------------------------------------------------------- */
1139
1140 // Support: IE<8
1141 // Verify that getAttribute really returns attributes and not properties
1142 // (excepting IE8 booleans)
1143 support.attributes = assert(function( el ) {
1144 el.className = "i";
1145 return !el.getAttribute("className");
1146 });
1147
1148 /* getElement(s)By*
1149 ---------------------------------------------------------------------- */
1150
1151 // Check if getElementsByTagName("*") returns only elements
1152 support.getElementsByTagName = assert(function( el ) {
1153 el.appendChild( document.createComment("") );
1154 return !el.getElementsByTagName("*").length;
1155 });
1156
1157 // Support: IE<9
1158 support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1159
1160 // Support: IE<10
1161 // Check if getElementById returns elements by name
1162 // The broken getElementById methods don't pick up programmatically-set names,
1163 // so use a roundabout getElementsByName test
1164 support.getById = assert(function( el ) {
1165 docElem.appendChild( el ).id = expando;
1166 return !document.getElementsByName || !document.getElementsByName( expando ).length;
1167 });
1168
1169 // ID filter and find
1170 if ( support.getById ) {
1171 Expr.filter["ID"] = function( id ) {
1172 var attrId = id.replace( runescape, funescape );
1173 return function( elem ) {
1174 return elem.getAttribute("id") === attrId;
1175 };
1176 };
1177 Expr.find["ID"] = function( id, context ) {
1178 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1179 var elem = context.getElementById( id );
1180 return elem ? [ elem ] : [];
1181 }
1182 };
1183 } else {
1184 Expr.filter["ID"] = function( id ) {
1185 var attrId = id.replace( runescape, funescape );
1186 return function( elem ) {
1187 var node = typeof elem.getAttributeNode !== "undefined" &&
1188 elem.getAttributeNode("id");
1189 return node && node.value === attrId;
1190 };
1191 };
1192
1193 // Support: IE 6 - 7 only
1194 // getElementById is not reliable as a find shortcut
1195 Expr.find["ID"] = function( id, context ) {
1196 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1197 var node, i, elems,
1198 elem = context.getElementById( id );
1199
1200 if ( elem ) {
1201
1202 // Verify the id attribute
1203 node = elem.getAttributeNode("id");
1204 if ( node && node.value === id ) {
1205 return [ elem ];
1206 }
1207
1208 // Fall back on getElementsByName
1209 elems = context.getElementsByName( id );
1210 i = 0;
1211 while ( (elem = elems[i++]) ) {
1212 node = elem.getAttributeNode("id");
1213 if ( node && node.value === id ) {
1214 return [ elem ];
1215 }
1216 }
1217 }
1218
1219 return [];
1220 }
1221 };
1222 }
1223
1224 // Tag
1225 Expr.find["TAG"] = support.getElementsByTagName ?
1226 function( tag, context ) {
1227 if ( typeof context.getElementsByTagName !== "undefined" ) {
1228 return context.getElementsByTagName( tag );
1229
1230 // DocumentFragment nodes don't have gEBTN
1231 } else if ( support.qsa ) {
1232 return context.querySelectorAll( tag );
1233 }
1234 } :
1235
1236 function( tag, context ) {
1237 var elem,
1238 tmp = [],
1239 i = 0,
1240 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1241 results = context.getElementsByTagName( tag );
1242
1243 // Filter out possible comments
1244 if ( tag === "*" ) {
1245 while ( (elem = results[i++]) ) {
1246 if ( elem.nodeType === 1 ) {
1247 tmp.push( elem );
1248 }
1249 }
1250
1251 return tmp;
1252 }
1253 return results;
1254 };
1255
1256 // Class
1257 Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1258 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1259 return context.getElementsByClassName( className );
1260 }
1261 };
1262
1263 /* QSA/matchesSelector
1264 ---------------------------------------------------------------------- */
1265
1266 // QSA and matchesSelector support
1267
1268 // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1269 rbuggyMatches = [];
1270
1271 // qSa(:focus) reports false when true (Chrome 21)
1272 // We allow this because of a bug in IE8/9 that throws an error
1273 // whenever `document.activeElement` is accessed on an iframe
1274 // So, we allow :focus to pass through QSA all the time to avoid the IE error
1275 // See https://bugs.jquery.com/ticket/13378
1276 rbuggyQSA = [];
1277
1278 if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1279 // Build QSA regex
1280 // Regex strategy adopted from Diego Perini
1281 assert(function( el ) {
1282 // Select is set to empty string on purpose
1283 // This is to test IE's treatment of not explicitly
1284 // setting a boolean content attribute,
1285 // since its presence should be enough
1286 // https://bugs.jquery.com/ticket/12359
1287 docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1288 "<select id='" + expando + "-\r\\' msallowcapture=''>" +
1289 "<option selected=''></option></select>";
1290
1291 // Support: IE8, Opera 11-12.16
1292 // Nothing should be selected when empty strings follow ^= or $= or *=
1293 // The test attribute must be unknown in Opera but "safe" for WinRT
1294 // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1295 if ( el.querySelectorAll("[msallowcapture^='']").length ) {
1296 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1297 }
1298
1299 // Support: IE8
1300 // Boolean attributes and "value" are not treated correctly
1301 if ( !el.querySelectorAll("[selected]").length ) {
1302 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1303 }
1304
1305 // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1306 if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1307 rbuggyQSA.push("~=");
1308 }
1309
1310 // Webkit/Opera - :checked should return selected option elements
1311 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1312 // IE8 throws error here and will not see later tests
1313 if ( !el.querySelectorAll(":checked").length ) {
1314 rbuggyQSA.push(":checked");
1315 }
1316
1317 // Support: Safari 8+, iOS 8+
1318 // https://bugs.webkit.org/show_bug.cgi?id=136851
1319 // In-page `selector#id sibling-combinator selector` fails
1320 if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1321 rbuggyQSA.push(".#.+[+~]");
1322 }
1323 });
1324
1325 assert(function( el ) {
1326 el.innerHTML = "<a href='' disabled='disabled'></a>" +
1327 "<select disabled='disabled'><option/></select>";
1328
1329 // Support: Windows 8 Native Apps
1330 // The type and name attributes are restricted during .innerHTML assignment
1331 var input = document.createElement("input");
1332 input.setAttribute( "type", "hidden" );
1333 el.appendChild( input ).setAttribute( "name", "D" );
1334
1335 // Support: IE8
1336 // Enforce case-sensitivity of name attribute
1337 if ( el.querySelectorAll("[name=d]").length ) {
1338 rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1339 }
1340
1341 // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1342 // IE8 throws error here and will not see later tests
1343 if ( el.querySelectorAll(":enabled").length !== 2 ) {
1344 rbuggyQSA.push( ":enabled", ":disabled" );
1345 }
1346
1347 // Support: IE9-11+
1348 // IE's :disabled selector does not pick up the children of disabled fieldsets
1349 docElem.appendChild( el ).disabled = true;
1350 if ( el.querySelectorAll(":disabled").length !== 2 ) {
1351 rbuggyQSA.push( ":enabled", ":disabled" );
1352 }
1353
1354 // Opera 10-11 does not throw on post-comma invalid pseudos
1355 el.querySelectorAll("*,:x");
1356 rbuggyQSA.push(",.*:");
1357 });
1358 }
1359
1360 if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1361 docElem.webkitMatchesSelector ||
1362 docElem.mozMatchesSelector ||
1363 docElem.oMatchesSelector ||
1364 docElem.msMatchesSelector) )) ) {
1365
1366 assert(function( el ) {
1367 // Check to see if it's possible to do matchesSelector
1368 // on a disconnected node (IE 9)
1369 support.disconnectedMatch = matches.call( el, "*" );
1370
1371 // This should fail with an exception
1372 // Gecko does not error, returns false instead
1373 matches.call( el, "[s!='']:x" );
1374 rbuggyMatches.push( "!=", pseudos );
1375 });
1376 }
1377
1378 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1379 rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1380
1381 /* Contains
1382 ---------------------------------------------------------------------- */
1383 hasCompare = rnative.test( docElem.compareDocumentPosition );
1384
1385 // Element contains another
1386 // Purposefully self-exclusive
1387 // As in, an element does not contain itself
1388 contains = hasCompare || rnative.test( docElem.contains ) ?
1389 function( a, b ) {
1390 var adown = a.nodeType === 9 ? a.documentElement : a,
1391 bup = b && b.parentNode;
1392 return a === bup || !!( bup && bup.nodeType === 1 && (
1393 adown.contains ?
1394 adown.contains( bup ) :
1395 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1396 ));
1397 } :
1398 function( a, b ) {
1399 if ( b ) {
1400 while ( (b = b.parentNode) ) {
1401 if ( b === a ) {
1402 return true;
1403 }
1404 }
1405 }
1406 return false;
1407 };
1408
1409 /* Sorting
1410 ---------------------------------------------------------------------- */
1411
1412 // Document order sorting
1413 sortOrder = hasCompare ?
1414 function( a, b ) {
1415
1416 // Flag for duplicate removal
1417 if ( a === b ) {
1418 hasDuplicate = true;
1419 return 0;
1420 }
1421
1422 // Sort on method existence if only one input has compareDocumentPosition
1423 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1424 if ( compare ) {
1425 return compare;
1426 }
1427
1428 // Calculate position if both inputs belong to the same document
1429 compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1430 a.compareDocumentPosition( b ) :
1431
1432 // Otherwise we know they are disconnected
1433 1;
1434
1435 // Disconnected nodes
1436 if ( compare & 1 ||
1437 (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1438
1439 // Choose the first element that is related to our preferred document
1440 if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1441 return -1;
1442 }
1443 if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1444 return 1;
1445 }
1446
1447 // Maintain original order
1448 return sortInput ?
1449 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1450 0;
1451 }
1452
1453 return compare & 4 ? -1 : 1;
1454 } :
1455 function( a, b ) {
1456 // Exit early if the nodes are identical
1457 if ( a === b ) {
1458 hasDuplicate = true;
1459 return 0;
1460 }
1461
1462 var cur,
1463 i = 0,
1464 aup = a.parentNode,
1465 bup = b.parentNode,
1466 ap = [ a ],
1467 bp = [ b ];
1468
1469 // Parentless nodes are either documents or disconnected
1470 if ( !aup || !bup ) {
1471 return a === document ? -1 :
1472 b === document ? 1 :
1473 aup ? -1 :
1474 bup ? 1 :
1475 sortInput ?
1476 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1477 0;
1478
1479 // If the nodes are siblings, we can do a quick check
1480 } else if ( aup === bup ) {
1481 return siblingCheck( a, b );
1482 }
1483
1484 // Otherwise we need full lists of their ancestors for comparison
1485 cur = a;
1486 while ( (cur = cur.parentNode) ) {
1487 ap.unshift( cur );
1488 }
1489 cur = b;
1490 while ( (cur = cur.parentNode) ) {
1491 bp.unshift( cur );
1492 }
1493
1494 // Walk down the tree looking for a discrepancy
1495 while ( ap[i] === bp[i] ) {
1496 i++;
1497 }
1498
1499 return i ?
1500 // Do a sibling check if the nodes have a common ancestor
1501 siblingCheck( ap[i], bp[i] ) :
1502
1503 // Otherwise nodes in our document sort first
1504 ap[i] === preferredDoc ? -1 :
1505 bp[i] === preferredDoc ? 1 :
1506 0;
1507 };
1508
1509 return document;
1510};
1511
1512Sizzle.matches = function( expr, elements ) {
1513 return Sizzle( expr, null, null, elements );
1514};
1515
1516Sizzle.matchesSelector = function( elem, expr ) {
1517 // Set document vars if needed
1518 if ( ( elem.ownerDocument || elem ) !== document ) {
1519 setDocument( elem );
1520 }
1521
1522 // Make sure that attribute selectors are quoted
1523 expr = expr.replace( rattributeQuotes, "='$1']" );
1524
1525 if ( support.matchesSelector && documentIsHTML &&
1526 !compilerCache[ expr + " " ] &&
1527 ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1528 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
1529
1530 try {
1531 var ret = matches.call( elem, expr );
1532
1533 // IE 9's matchesSelector returns false on disconnected nodes
1534 if ( ret || support.disconnectedMatch ||
1535 // As well, disconnected nodes are said to be in a document
1536 // fragment in IE 9
1537 elem.document && elem.document.nodeType !== 11 ) {
1538 return ret;
1539 }
1540 } catch (e) {}
1541 }
1542
1543 return Sizzle( expr, document, null, [ elem ] ).length > 0;
1544};
1545
1546Sizzle.contains = function( context, elem ) {
1547 // Set document vars if needed
1548 if ( ( context.ownerDocument || context ) !== document ) {
1549 setDocument( context );
1550 }
1551 return contains( context, elem );
1552};
1553
1554Sizzle.attr = function( elem, name ) {
1555 // Set document vars if needed
1556 if ( ( elem.ownerDocument || elem ) !== document ) {
1557 setDocument( elem );
1558 }
1559
1560 var fn = Expr.attrHandle[ name.toLowerCase() ],
1561 // Don't get fooled by Object.prototype properties (jQuery #13807)
1562 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1563 fn( elem, name, !documentIsHTML ) :
1564 undefined;
1565
1566 return val !== undefined ?
1567 val :
1568 support.attributes || !documentIsHTML ?
1569 elem.getAttribute( name ) :
1570 (val = elem.getAttributeNode(name)) && val.specified ?
1571 val.value :
1572 null;
1573};
1574
1575Sizzle.escape = function( sel ) {
1576 return (sel + "").replace( rcssescape, fcssescape );
1577};
1578
1579Sizzle.error = function( msg ) {
1580 throw new Error( "Syntax error, unrecognized expression: " + msg );
1581};
1582
1583/**
1584 * Document sorting and removing duplicates
1585 * @param {ArrayLike} results
1586 */
1587Sizzle.uniqueSort = function( results ) {
1588 var elem,
1589 duplicates = [],
1590 j = 0,
1591 i = 0;
1592
1593 // Unless we *know* we can detect duplicates, assume their presence
1594 hasDuplicate = !support.detectDuplicates;
1595 sortInput = !support.sortStable && results.slice( 0 );
1596 results.sort( sortOrder );
1597
1598 if ( hasDuplicate ) {
1599 while ( (elem = results[i++]) ) {
1600 if ( elem === results[ i ] ) {
1601 j = duplicates.push( i );
1602 }
1603 }
1604 while ( j-- ) {
1605 results.splice( duplicates[ j ], 1 );
1606 }
1607 }
1608
1609 // Clear input after sorting to release objects
1610 // See https://github.com/jquery/sizzle/pull/225
1611 sortInput = null;
1612
1613 return results;
1614};
1615
1616/**
1617 * Utility function for retrieving the text value of an array of DOM nodes
1618 * @param {Array|Element} elem
1619 */
1620getText = Sizzle.getText = function( elem ) {
1621 var node,
1622 ret = "",
1623 i = 0,
1624 nodeType = elem.nodeType;
1625
1626 if ( !nodeType ) {
1627 // If no nodeType, this is expected to be an array
1628 while ( (node = elem[i++]) ) {
1629 // Do not traverse comment nodes
1630 ret += getText( node );
1631 }
1632 } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1633 // Use textContent for elements
1634 // innerText usage removed for consistency of new lines (jQuery #11153)
1635 if ( typeof elem.textContent === "string" ) {
1636 return elem.textContent;
1637 } else {
1638 // Traverse its children
1639 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1640 ret += getText( elem );
1641 }
1642 }
1643 } else if ( nodeType === 3 || nodeType === 4 ) {
1644 return elem.nodeValue;
1645 }
1646 // Do not include comment or processing instruction nodes
1647
1648 return ret;
1649};
1650
1651Expr = Sizzle.selectors = {
1652
1653 // Can be adjusted by the user
1654 cacheLength: 50,
1655
1656 createPseudo: markFunction,
1657
1658 match: matchExpr,
1659
1660 attrHandle: {},
1661
1662 find: {},
1663
1664 relative: {
1665 ">": { dir: "parentNode", first: true },
1666 " ": { dir: "parentNode" },
1667 "+": { dir: "previousSibling", first: true },
1668 "~": { dir: "previousSibling" }
1669 },
1670
1671 preFilter: {
1672 "ATTR": function( match ) {
1673 match[1] = match[1].replace( runescape, funescape );
1674
1675 // Move the given value to match[3] whether quoted or unquoted
1676 match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1677
1678 if ( match[2] === "~=" ) {
1679 match[3] = " " + match[3] + " ";
1680 }
1681
1682 return match.slice( 0, 4 );
1683 },
1684
1685 "CHILD": function( match ) {
1686 /* matches from matchExpr["CHILD"]
1687 1 type (only|nth|...)
1688 2 what (child|of-type)
1689 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1690 4 xn-component of xn+y argument ([+-]?\d*n|)
1691 5 sign of xn-component
1692 6 x of xn-component
1693 7 sign of y-component
1694 8 y of y-component
1695 */
1696 match[1] = match[1].toLowerCase();
1697
1698 if ( match[1].slice( 0, 3 ) === "nth" ) {
1699 // nth-* requires argument
1700 if ( !match[3] ) {
1701 Sizzle.error( match[0] );
1702 }
1703
1704 // numeric x and y parameters for Expr.filter.CHILD
1705 // remember that false/true cast respectively to 0/1
1706 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1707 match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1708
1709 // other types prohibit arguments
1710 } else if ( match[3] ) {
1711 Sizzle.error( match[0] );
1712 }
1713
1714 return match;
1715 },
1716
1717 "PSEUDO": function( match ) {
1718 var excess,
1719 unquoted = !match[6] && match[2];
1720
1721 if ( matchExpr["CHILD"].test( match[0] ) ) {
1722 return null;
1723 }
1724
1725 // Accept quoted arguments as-is
1726 if ( match[3] ) {
1727 match[2] = match[4] || match[5] || "";
1728
1729 // Strip excess characters from unquoted arguments
1730 } else if ( unquoted && rpseudo.test( unquoted ) &&
1731 // Get excess from tokenize (recursively)
1732 (excess = tokenize( unquoted, true )) &&
1733 // advance to the next closing parenthesis
1734 (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1735
1736 // excess is a negative index
1737 match[0] = match[0].slice( 0, excess );
1738 match[2] = unquoted.slice( 0, excess );
1739 }
1740
1741 // Return only captures needed by the pseudo filter method (type and argument)
1742 return match.slice( 0, 3 );
1743 }
1744 },
1745
1746 filter: {
1747
1748 "TAG": function( nodeNameSelector ) {
1749 var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1750 return nodeNameSelector === "*" ?
1751 function() { return true; } :
1752 function( elem ) {
1753 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1754 };
1755 },
1756
1757 "CLASS": function( className ) {
1758 var pattern = classCache[ className + " " ];
1759
1760 return pattern ||
1761 (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1762 classCache( className, function( elem ) {
1763 return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1764 });
1765 },
1766
1767 "ATTR": function( name, operator, check ) {
1768 return function( elem ) {
1769 var result = Sizzle.attr( elem, name );
1770
1771 if ( result == null ) {
1772 return operator === "!=";
1773 }
1774 if ( !operator ) {
1775 return true;
1776 }
1777
1778 result += "";
1779
1780 return operator === "=" ? result === check :
1781 operator === "!=" ? result !== check :
1782 operator === "^=" ? check && result.indexOf( check ) === 0 :
1783 operator === "*=" ? check && result.indexOf( check ) > -1 :
1784 operator === "$=" ? check && result.slice( -check.length ) === check :
1785 operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1786 operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1787 false;
1788 };
1789 },
1790
1791 "CHILD": function( type, what, argument, first, last ) {
1792 var simple = type.slice( 0, 3 ) !== "nth",
1793 forward = type.slice( -4 ) !== "last",
1794 ofType = what === "of-type";
1795
1796 return first === 1 && last === 0 ?
1797
1798 // Shortcut for :nth-*(n)
1799 function( elem ) {
1800 return !!elem.parentNode;
1801 } :
1802
1803 function( elem, context, xml ) {
1804 var cache, uniqueCache, outerCache, node, nodeIndex, start,
1805 dir = simple !== forward ? "nextSibling" : "previousSibling",
1806 parent = elem.parentNode,
1807 name = ofType && elem.nodeName.toLowerCase(),
1808 useCache = !xml && !ofType,
1809 diff = false;
1810
1811 if ( parent ) {
1812
1813 // :(first|last|only)-(child|of-type)
1814 if ( simple ) {
1815 while ( dir ) {
1816 node = elem;
1817 while ( (node = node[ dir ]) ) {
1818 if ( ofType ?
1819 node.nodeName.toLowerCase() === name :
1820 node.nodeType === 1 ) {
1821
1822 return false;
1823 }
1824 }
1825 // Reverse direction for :only-* (if we haven't yet done so)
1826 start = dir = type === "only" && !start && "nextSibling";
1827 }
1828 return true;
1829 }
1830
1831 start = [ forward ? parent.firstChild : parent.lastChild ];
1832
1833 // non-xml :nth-child(...) stores cache data on `parent`
1834 if ( forward && useCache ) {
1835
1836 // Seek `elem` from a previously-cached index
1837
1838 // ...in a gzip-friendly way
1839 node = parent;
1840 outerCache = node[ expando ] || (node[ expando ] = {});
1841
1842 // Support: IE <9 only
1843 // Defend against cloned attroperties (jQuery gh-1709)
1844 uniqueCache = outerCache[ node.uniqueID ] ||
1845 (outerCache[ node.uniqueID ] = {});
1846
1847 cache = uniqueCache[ type ] || [];
1848 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1849 diff = nodeIndex && cache[ 2 ];
1850 node = nodeIndex && parent.childNodes[ nodeIndex ];
1851
1852 while ( (node = ++nodeIndex && node && node[ dir ] ||
1853
1854 // Fallback to seeking `elem` from the start
1855 (diff = nodeIndex = 0) || start.pop()) ) {
1856
1857 // When found, cache indexes on `parent` and break
1858 if ( node.nodeType === 1 && ++diff && node === elem ) {
1859 uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1860 break;
1861 }
1862 }
1863
1864 } else {
1865 // Use previously-cached element index if available
1866 if ( useCache ) {
1867 // ...in a gzip-friendly way
1868 node = elem;
1869 outerCache = node[ expando ] || (node[ expando ] = {});
1870
1871 // Support: IE <9 only
1872 // Defend against cloned attroperties (jQuery gh-1709)
1873 uniqueCache = outerCache[ node.uniqueID ] ||
1874 (outerCache[ node.uniqueID ] = {});
1875
1876 cache = uniqueCache[ type ] || [];
1877 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1878 diff = nodeIndex;
1879 }
1880
1881 // xml :nth-child(...)
1882 // or :nth-last-child(...) or :nth(-last)?-of-type(...)
1883 if ( diff === false ) {
1884 // Use the same loop as above to seek `elem` from the start
1885 while ( (node = ++nodeIndex && node && node[ dir ] ||
1886 (diff = nodeIndex = 0) || start.pop()) ) {
1887
1888 if ( ( ofType ?
1889 node.nodeName.toLowerCase() === name :
1890 node.nodeType === 1 ) &&
1891 ++diff ) {
1892
1893 // Cache the index of each encountered element
1894 if ( useCache ) {
1895 outerCache = node[ expando ] || (node[ expando ] = {});
1896
1897 // Support: IE <9 only
1898 // Defend against cloned attroperties (jQuery gh-1709)
1899 uniqueCache = outerCache[ node.uniqueID ] ||
1900 (outerCache[ node.uniqueID ] = {});
1901
1902 uniqueCache[ type ] = [ dirruns, diff ];
1903 }
1904
1905 if ( node === elem ) {
1906 break;
1907 }
1908 }
1909 }
1910 }
1911 }
1912
1913 // Incorporate the offset, then check against cycle size
1914 diff -= last;
1915 return diff === first || ( diff % first === 0 && diff / first >= 0 );
1916 }
1917 };
1918 },
1919
1920 "PSEUDO": function( pseudo, argument ) {
1921 // pseudo-class names are case-insensitive
1922 // http://www.w3.org/TR/selectors/#pseudo-classes
1923 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1924 // Remember that setFilters inherits from pseudos
1925 var args,
1926 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1927 Sizzle.error( "unsupported pseudo: " + pseudo );
1928
1929 // The user may use createPseudo to indicate that
1930 // arguments are needed to create the filter function
1931 // just as Sizzle does
1932 if ( fn[ expando ] ) {
1933 return fn( argument );
1934 }
1935
1936 // But maintain support for old signatures
1937 if ( fn.length > 1 ) {
1938 args = [ pseudo, pseudo, "", argument ];
1939 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1940 markFunction(function( seed, matches ) {
1941 var idx,
1942 matched = fn( seed, argument ),
1943 i = matched.length;
1944 while ( i-- ) {
1945 idx = indexOf( seed, matched[i] );
1946 seed[ idx ] = !( matches[ idx ] = matched[i] );
1947 }
1948 }) :
1949 function( elem ) {
1950 return fn( elem, 0, args );
1951 };
1952 }
1953
1954 return fn;
1955 }
1956 },
1957
1958 pseudos: {
1959 // Potentially complex pseudos
1960 "not": markFunction(function( selector ) {
1961 // Trim the selector passed to compile
1962 // to avoid treating leading and trailing
1963 // spaces as combinators
1964 var input = [],
1965 results = [],
1966 matcher = compile( selector.replace( rtrim, "$1" ) );
1967
1968 return matcher[ expando ] ?
1969 markFunction(function( seed, matches, context, xml ) {
1970 var elem,
1971 unmatched = matcher( seed, null, xml, [] ),
1972 i = seed.length;
1973
1974 // Match elements unmatched by `matcher`
1975 while ( i-- ) {
1976 if ( (elem = unmatched[i]) ) {
1977 seed[i] = !(matches[i] = elem);
1978 }
1979 }
1980 }) :
1981 function( elem, context, xml ) {
1982 input[0] = elem;
1983 matcher( input, null, xml, results );
1984 // Don't keep the element (issue #299)
1985 input[0] = null;
1986 return !results.pop();
1987 };
1988 }),
1989
1990 "has": markFunction(function( selector ) {
1991 return function( elem ) {
1992 return Sizzle( selector, elem ).length > 0;
1993 };
1994 }),
1995
1996 "contains": markFunction(function( text ) {
1997 text = text.replace( runescape, funescape );
1998 return function( elem ) {
1999 return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2000 };
2001 }),
2002
2003 // "Whether an element is represented by a :lang() selector
2004 // is based solely on the element's language value
2005 // being equal to the identifier C,
2006 // or beginning with the identifier C immediately followed by "-".
2007 // The matching of C against the element's language value is performed case-insensitively.
2008 // The identifier C does not have to be a valid language name."
2009 // http://www.w3.org/TR/selectors/#lang-pseudo
2010 "lang": markFunction( function( lang ) {
2011 // lang value must be a valid identifier
2012 if ( !ridentifier.test(lang || "") ) {
2013 Sizzle.error( "unsupported lang: " + lang );
2014 }
2015 lang = lang.replace( runescape, funescape ).toLowerCase();
2016 return function( elem ) {
2017 var elemLang;
2018 do {
2019 if ( (elemLang = documentIsHTML ?
2020 elem.lang :
2021 elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2022
2023 elemLang = elemLang.toLowerCase();
2024 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2025 }
2026 } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2027 return false;
2028 };
2029 }),
2030
2031 // Miscellaneous
2032 "target": function( elem ) {
2033 var hash = window.location && window.location.hash;
2034 return hash && hash.slice( 1 ) === elem.id;
2035 },
2036
2037 "root": function( elem ) {
2038 return elem === docElem;
2039 },
2040
2041 "focus": function( elem ) {
2042 return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2043 },
2044
2045 // Boolean properties
2046 "enabled": createDisabledPseudo( false ),
2047 "disabled": createDisabledPseudo( true ),
2048
2049 "checked": function( elem ) {
2050 // In CSS3, :checked should return both checked and selected elements
2051 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2052 var nodeName = elem.nodeName.toLowerCase();
2053 return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2054 },
2055
2056 "selected": function( elem ) {
2057 // Accessing this property makes selected-by-default
2058 // options in Safari work properly
2059 if ( elem.parentNode ) {
2060 elem.parentNode.selectedIndex;
2061 }
2062
2063 return elem.selected === true;
2064 },
2065
2066 // Contents
2067 "empty": function( elem ) {
2068 // http://www.w3.org/TR/selectors/#empty-pseudo
2069 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2070 // but not by others (comment: 8; processing instruction: 7; etc.)
2071 // nodeType < 6 works because attributes (2) do not appear as children
2072 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2073 if ( elem.nodeType < 6 ) {
2074 return false;
2075 }
2076 }
2077 return true;
2078 },
2079
2080 "parent": function( elem ) {
2081 return !Expr.pseudos["empty"]( elem );
2082 },
2083
2084 // Element/input types
2085 "header": function( elem ) {
2086 return rheader.test( elem.nodeName );
2087 },
2088
2089 "input": function( elem ) {
2090 return rinputs.test( elem.nodeName );
2091 },
2092
2093 "button": function( elem ) {
2094 var name = elem.nodeName.toLowerCase();
2095 return name === "input" && elem.type === "button" || name === "button";
2096 },
2097
2098 "text": function( elem ) {
2099 var attr;
2100 return elem.nodeName.toLowerCase() === "input" &&
2101 elem.type === "text" &&
2102
2103 // Support: IE<8
2104 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2105 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
2106 },
2107
2108 // Position-in-collection
2109 "first": createPositionalPseudo(function() {
2110 return [ 0 ];
2111 }),
2112
2113 "last": createPositionalPseudo(function( matchIndexes, length ) {
2114 return [ length - 1 ];
2115 }),
2116
2117 "eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2118 return [ argument < 0 ? argument + length : argument ];
2119 }),
2120
2121 "even": createPositionalPseudo(function( matchIndexes, length ) {
2122 var i = 0;
2123 for ( ; i < length; i += 2 ) {
2124 matchIndexes.push( i );
2125 }
2126 return matchIndexes;
2127 }),
2128
2129 "odd": createPositionalPseudo(function( matchIndexes, length ) {
2130 var i = 1;
2131 for ( ; i < length; i += 2 ) {
2132 matchIndexes.push( i );
2133 }
2134 return matchIndexes;
2135 }),
2136
2137 "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2138 var i = argument < 0 ? argument + length : argument;
2139 for ( ; --i >= 0; ) {
2140 matchIndexes.push( i );
2141 }
2142 return matchIndexes;
2143 }),
2144
2145 "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2146 var i = argument < 0 ? argument + length : argument;
2147 for ( ; ++i < length; ) {
2148 matchIndexes.push( i );
2149 }
2150 return matchIndexes;
2151 })
2152 }
2153};
2154
2155Expr.pseudos["nth"] = Expr.pseudos["eq"];
2156
2157// Add button/input type pseudos
2158for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2159 Expr.pseudos[ i ] = createInputPseudo( i );
2160}
2161for ( i in { submit: true, reset: true } ) {
2162 Expr.pseudos[ i ] = createButtonPseudo( i );
2163}
2164
2165// Easy API for creating new setFilters
2166function setFilters() {}
2167setFilters.prototype = Expr.filters = Expr.pseudos;
2168Expr.setFilters = new setFilters();
2169
2170tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2171 var matched, match, tokens, type,
2172 soFar, groups, preFilters,
2173 cached = tokenCache[ selector + " " ];
2174
2175 if ( cached ) {
2176 return parseOnly ? 0 : cached.slice( 0 );
2177 }
2178
2179 soFar = selector;
2180 groups = [];
2181 preFilters = Expr.preFilter;
2182
2183 while ( soFar ) {
2184
2185 // Comma and first run
2186 if ( !matched || (match = rcomma.exec( soFar )) ) {
2187 if ( match ) {
2188 // Don't consume trailing commas as valid
2189 soFar = soFar.slice( match[0].length ) || soFar;
2190 }
2191 groups.push( (tokens = []) );
2192 }
2193
2194 matched = false;
2195
2196 // Combinators
2197 if ( (match = rcombinators.exec( soFar )) ) {
2198 matched = match.shift();
2199 tokens.push({
2200 value: matched,
2201 // Cast descendant combinators to space
2202 type: match[0].replace( rtrim, " " )
2203 });
2204 soFar = soFar.slice( matched.length );
2205 }
2206
2207 // Filters
2208 for ( type in Expr.filter ) {
2209 if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2210 (match = preFilters[ type ]( match ))) ) {
2211 matched = match.shift();
2212 tokens.push({
2213 value: matched,
2214 type: type,
2215 matches: match
2216 });
2217 soFar = soFar.slice( matched.length );
2218 }
2219 }
2220
2221 if ( !matched ) {
2222 break;
2223 }
2224 }
2225
2226 // Return the length of the invalid excess
2227 // if we're just parsing
2228 // Otherwise, throw an error or return tokens
2229 return parseOnly ?
2230 soFar.length :
2231 soFar ?
2232 Sizzle.error( selector ) :
2233 // Cache the tokens
2234 tokenCache( selector, groups ).slice( 0 );
2235};
2236
2237function toSelector( tokens ) {
2238 var i = 0,
2239 len = tokens.length,
2240 selector = "";
2241 for ( ; i < len; i++ ) {
2242 selector += tokens[i].value;
2243 }
2244 return selector;
2245}
2246
2247function addCombinator( matcher, combinator, base ) {
2248 var dir = combinator.dir,
2249 skip = combinator.next,
2250 key = skip || dir,
2251 checkNonElements = base && key === "parentNode",
2252 doneName = done++;
2253
2254 return combinator.first ?
2255 // Check against closest ancestor/preceding element
2256 function( elem, context, xml ) {
2257 while ( (elem = elem[ dir ]) ) {
2258 if ( elem.nodeType === 1 || checkNonElements ) {
2259 return matcher( elem, context, xml );
2260 }
2261 }
2262 return false;
2263 } :
2264
2265 // Check against all ancestor/preceding elements
2266 function( elem, context, xml ) {
2267 var oldCache, uniqueCache, outerCache,
2268 newCache = [ dirruns, doneName ];
2269
2270 // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2271 if ( xml ) {
2272 while ( (elem = elem[ dir ]) ) {
2273 if ( elem.nodeType === 1 || checkNonElements ) {
2274 if ( matcher( elem, context, xml ) ) {
2275 return true;
2276 }
2277 }
2278 }
2279 } else {
2280 while ( (elem = elem[ dir ]) ) {
2281 if ( elem.nodeType === 1 || checkNonElements ) {
2282 outerCache = elem[ expando ] || (elem[ expando ] = {});
2283
2284 // Support: IE <9 only
2285 // Defend against cloned attroperties (jQuery gh-1709)
2286 uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2287
2288 if ( skip && skip === elem.nodeName.toLowerCase() ) {
2289 elem = elem[ dir ] || elem;
2290 } else if ( (oldCache = uniqueCache[ key ]) &&
2291 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2292
2293 // Assign to newCache so results back-propagate to previous elements
2294 return (newCache[ 2 ] = oldCache[ 2 ]);
2295 } else {
2296 // Reuse newcache so results back-propagate to previous elements
2297 uniqueCache[ key ] = newCache;
2298
2299 // A match means we're done; a fail means we have to keep checking
2300 if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2301 return true;
2302 }
2303 }
2304 }
2305 }
2306 }
2307 return false;
2308 };
2309}
2310
2311function elementMatcher( matchers ) {
2312 return matchers.length > 1 ?
2313 function( elem, context, xml ) {
2314 var i = matchers.length;
2315 while ( i-- ) {
2316 if ( !matchers[i]( elem, context, xml ) ) {
2317 return false;
2318 }
2319 }
2320 return true;
2321 } :
2322 matchers[0];
2323}
2324
2325function multipleContexts( selector, contexts, results ) {
2326 var i = 0,
2327 len = contexts.length;
2328 for ( ; i < len; i++ ) {
2329 Sizzle( selector, contexts[i], results );
2330 }
2331 return results;
2332}
2333
2334function condense( unmatched, map, filter, context, xml ) {
2335 var elem,
2336 newUnmatched = [],
2337 i = 0,
2338 len = unmatched.length,
2339 mapped = map != null;
2340
2341 for ( ; i < len; i++ ) {
2342 if ( (elem = unmatched[i]) ) {
2343 if ( !filter || filter( elem, context, xml ) ) {
2344 newUnmatched.push( elem );
2345 if ( mapped ) {
2346 map.push( i );
2347 }
2348 }
2349 }
2350 }
2351
2352 return newUnmatched;
2353}
2354
2355function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2356 if ( postFilter && !postFilter[ expando ] ) {
2357 postFilter = setMatcher( postFilter );
2358 }
2359 if ( postFinder && !postFinder[ expando ] ) {
2360 postFinder = setMatcher( postFinder, postSelector );
2361 }
2362 return markFunction(function( seed, results, context, xml ) {
2363 var temp, i, elem,
2364 preMap = [],
2365 postMap = [],
2366 preexisting = results.length,
2367
2368 // Get initial elements from seed or context
2369 elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2370
2371 // Prefilter to get matcher input, preserving a map for seed-results synchronization
2372 matcherIn = preFilter && ( seed || !selector ) ?
2373 condense( elems, preMap, preFilter, context, xml ) :
2374 elems,
2375
2376 matcherOut = matcher ?
2377 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2378 postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2379
2380 // ...intermediate processing is necessary
2381 [] :
2382
2383 // ...otherwise use results directly
2384 results :
2385 matcherIn;
2386
2387 // Find primary matches
2388 if ( matcher ) {
2389 matcher( matcherIn, matcherOut, context, xml );
2390 }
2391
2392 // Apply postFilter
2393 if ( postFilter ) {
2394 temp = condense( matcherOut, postMap );
2395 postFilter( temp, [], context, xml );
2396
2397 // Un-match failing elements by moving them back to matcherIn
2398 i = temp.length;
2399 while ( i-- ) {
2400 if ( (elem = temp[i]) ) {
2401 matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2402 }
2403 }
2404 }
2405
2406 if ( seed ) {
2407 if ( postFinder || preFilter ) {
2408 if ( postFinder ) {
2409 // Get the final matcherOut by condensing this intermediate into postFinder contexts
2410 temp = [];
2411 i = matcherOut.length;
2412 while ( i-- ) {
2413 if ( (elem = matcherOut[i]) ) {
2414 // Restore matcherIn since elem is not yet a final match
2415 temp.push( (matcherIn[i] = elem) );
2416 }
2417 }
2418 postFinder( null, (matcherOut = []), temp, xml );
2419 }
2420
2421 // Move matched elements from seed to results to keep them synchronized
2422 i = matcherOut.length;
2423 while ( i-- ) {
2424 if ( (elem = matcherOut[i]) &&
2425 (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2426
2427 seed[temp] = !(results[temp] = elem);
2428 }
2429 }
2430 }
2431
2432 // Add elements to results, through postFinder if defined
2433 } else {
2434 matcherOut = condense(
2435 matcherOut === results ?
2436 matcherOut.splice( preexisting, matcherOut.length ) :
2437 matcherOut
2438 );
2439 if ( postFinder ) {
2440 postFinder( null, results, matcherOut, xml );
2441 } else {
2442 push.apply( results, matcherOut );
2443 }
2444 }
2445 });
2446}
2447
2448function matcherFromTokens( tokens ) {
2449 var checkContext, matcher, j,
2450 len = tokens.length,
2451 leadingRelative = Expr.relative[ tokens[0].type ],
2452 implicitRelative = leadingRelative || Expr.relative[" "],
2453 i = leadingRelative ? 1 : 0,
2454
2455 // The foundational matcher ensures that elements are reachable from top-level context(s)
2456 matchContext = addCombinator( function( elem ) {
2457 return elem === checkContext;
2458 }, implicitRelative, true ),
2459 matchAnyContext = addCombinator( function( elem ) {
2460 return indexOf( checkContext, elem ) > -1;
2461 }, implicitRelative, true ),
2462 matchers = [ function( elem, context, xml ) {
2463 var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2464 (checkContext = context).nodeType ?
2465 matchContext( elem, context, xml ) :
2466 matchAnyContext( elem, context, xml ) );
2467 // Avoid hanging onto element (issue #299)
2468 checkContext = null;
2469 return ret;
2470 } ];
2471
2472 for ( ; i < len; i++ ) {
2473 if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2474 matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2475 } else {
2476 matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2477
2478 // Return special upon seeing a positional matcher
2479 if ( matcher[ expando ] ) {
2480 // Find the next relative operator (if any) for proper handling
2481 j = ++i;
2482 for ( ; j < len; j++ ) {
2483 if ( Expr.relative[ tokens[j].type ] ) {
2484 break;
2485 }
2486 }
2487 return setMatcher(
2488 i > 1 && elementMatcher( matchers ),
2489 i > 1 && toSelector(
2490 // If the preceding token was a descendant combinator, insert an implicit any-element `*`
2491 tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2492 ).replace( rtrim, "$1" ),
2493 matcher,
2494 i < j && matcherFromTokens( tokens.slice( i, j ) ),
2495 j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2496 j < len && toSelector( tokens )
2497 );
2498 }
2499 matchers.push( matcher );
2500 }
2501 }
2502
2503 return elementMatcher( matchers );
2504}
2505
2506function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2507 var bySet = setMatchers.length > 0,
2508 byElement = elementMatchers.length > 0,
2509 superMatcher = function( seed, context, xml, results, outermost ) {
2510 var elem, j, matcher,
2511 matchedCount = 0,
2512 i = "0",
2513 unmatched = seed && [],
2514 setMatched = [],
2515 contextBackup = outermostContext,
2516 // We must always have either seed elements or outermost context
2517 elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2518 // Use integer dirruns iff this is the outermost matcher
2519 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2520 len = elems.length;
2521
2522 if ( outermost ) {
2523 outermostContext = context === document || context || outermost;
2524 }
2525
2526 // Add elements passing elementMatchers directly to results
2527 // Support: IE<9, Safari
2528 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2529 for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2530 if ( byElement && elem ) {
2531 j = 0;
2532 if ( !context && elem.ownerDocument !== document ) {
2533 setDocument( elem );
2534 xml = !documentIsHTML;
2535 }
2536 while ( (matcher = elementMatchers[j++]) ) {
2537 if ( matcher( elem, context || document, xml) ) {
2538 results.push( elem );
2539 break;
2540 }
2541 }
2542 if ( outermost ) {
2543 dirruns = dirrunsUnique;
2544 }
2545 }
2546
2547 // Track unmatched elements for set filters
2548 if ( bySet ) {
2549 // They will have gone through all possible matchers
2550 if ( (elem = !matcher && elem) ) {
2551 matchedCount--;
2552 }
2553
2554 // Lengthen the array for every element, matched or not
2555 if ( seed ) {
2556 unmatched.push( elem );
2557 }
2558 }
2559 }
2560
2561 // `i` is now the count of elements visited above, and adding it to `matchedCount`
2562 // makes the latter nonnegative.
2563 matchedCount += i;
2564
2565 // Apply set filters to unmatched elements
2566 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2567 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2568 // no element matchers and no seed.
2569 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2570 // case, which will result in a "00" `matchedCount` that differs from `i` but is also
2571 // numerically zero.
2572 if ( bySet && i !== matchedCount ) {
2573 j = 0;
2574 while ( (matcher = setMatchers[j++]) ) {
2575 matcher( unmatched, setMatched, context, xml );
2576 }
2577
2578 if ( seed ) {
2579 // Reintegrate element matches to eliminate the need for sorting
2580 if ( matchedCount > 0 ) {
2581 while ( i-- ) {
2582 if ( !(unmatched[i] || setMatched[i]) ) {
2583 setMatched[i] = pop.call( results );
2584 }
2585 }
2586 }
2587
2588 // Discard index placeholder values to get only actual matches
2589 setMatched = condense( setMatched );
2590 }
2591
2592 // Add matches to results
2593 push.apply( results, setMatched );
2594
2595 // Seedless set matches succeeding multiple successful matchers stipulate sorting
2596 if ( outermost && !seed && setMatched.length > 0 &&
2597 ( matchedCount + setMatchers.length ) > 1 ) {
2598
2599 Sizzle.uniqueSort( results );
2600 }
2601 }
2602
2603 // Override manipulation of globals by nested matchers
2604 if ( outermost ) {
2605 dirruns = dirrunsUnique;
2606 outermostContext = contextBackup;
2607 }
2608
2609 return unmatched;
2610 };
2611
2612 return bySet ?
2613 markFunction( superMatcher ) :
2614 superMatcher;
2615}
2616
2617compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2618 var i,
2619 setMatchers = [],
2620 elementMatchers = [],
2621 cached = compilerCache[ selector + " " ];
2622
2623 if ( !cached ) {
2624 // Generate a function of recursive functions that can be used to check each element
2625 if ( !match ) {
2626 match = tokenize( selector );
2627 }
2628 i = match.length;
2629 while ( i-- ) {
2630 cached = matcherFromTokens( match[i] );
2631 if ( cached[ expando ] ) {
2632 setMatchers.push( cached );
2633 } else {
2634 elementMatchers.push( cached );
2635 }
2636 }
2637
2638 // Cache the compiled function
2639 cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2640
2641 // Save selector and tokenization
2642 cached.selector = selector;
2643 }
2644 return cached;
2645};
2646
2647/**
2648 * A low-level selection function that works with Sizzle's compiled
2649 * selector functions
2650 * @param {String|Function} selector A selector or a pre-compiled
2651 * selector function built with Sizzle.compile
2652 * @param {Element} context
2653 * @param {Array} [results]
2654 * @param {Array} [seed] A set of elements to match against
2655 */
2656select = Sizzle.select = function( selector, context, results, seed ) {
2657 var i, tokens, token, type, find,
2658 compiled = typeof selector === "function" && selector,
2659 match = !seed && tokenize( (selector = compiled.selector || selector) );
2660
2661 results = results || [];
2662
2663 // Try to minimize operations if there is only one selector in the list and no seed
2664 // (the latter of which guarantees us context)
2665 if ( match.length === 1 ) {
2666
2667 // Reduce context if the leading compound selector is an ID
2668 tokens = match[0] = match[0].slice( 0 );
2669 if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2670 context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
2671
2672 context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2673 if ( !context ) {
2674 return results;
2675
2676 // Precompiled matchers will still verify ancestry, so step up a level
2677 } else if ( compiled ) {
2678 context = context.parentNode;
2679 }
2680
2681 selector = selector.slice( tokens.shift().value.length );
2682 }
2683
2684 // Fetch a seed set for right-to-left matching
2685 i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2686 while ( i-- ) {
2687 token = tokens[i];
2688
2689 // Abort if we hit a combinator
2690 if ( Expr.relative[ (type = token.type) ] ) {
2691 break;
2692 }
2693 if ( (find = Expr.find[ type ]) ) {
2694 // Search, expanding context for leading sibling combinators
2695 if ( (seed = find(
2696 token.matches[0].replace( runescape, funescape ),
2697 rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2698 )) ) {
2699
2700 // If seed is empty or no tokens remain, we can return early
2701 tokens.splice( i, 1 );
2702 selector = seed.length && toSelector( tokens );
2703 if ( !selector ) {
2704 push.apply( results, seed );
2705 return results;
2706 }
2707
2708 break;
2709 }
2710 }
2711 }
2712 }
2713
2714 // Compile and execute a filtering function if one is not provided
2715 // Provide `match` to avoid retokenization if we modified the selector above
2716 ( compiled || compile( selector, match ) )(
2717 seed,
2718 context,
2719 !documentIsHTML,
2720 results,
2721 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2722 );
2723 return results;
2724};
2725
2726// One-time assignments
2727
2728// Sort stability
2729support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2730
2731// Support: Chrome 14-35+
2732// Always assume duplicates if they aren't passed to the comparison function
2733support.detectDuplicates = !!hasDuplicate;
2734
2735// Initialize against the default document
2736setDocument();
2737
2738// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2739// Detached nodes confoundingly follow *each other*
2740support.sortDetached = assert(function( el ) {
2741 // Should return 1, but returns 4 (following)
2742 return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
2743});
2744
2745// Support: IE<8
2746// Prevent attribute/property "interpolation"
2747// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2748if ( !assert(function( el ) {
2749 el.innerHTML = "<a href='#'></a>";
2750 return el.firstChild.getAttribute("href") === "#" ;
2751}) ) {
2752 addHandle( "type|href|height|width", function( elem, name, isXML ) {
2753 if ( !isXML ) {
2754 return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2755 }
2756 });
2757}
2758
2759// Support: IE<9
2760// Use defaultValue in place of getAttribute("value")
2761if ( !support.attributes || !assert(function( el ) {
2762 el.innerHTML = "<input/>";
2763 el.firstChild.setAttribute( "value", "" );
2764 return el.firstChild.getAttribute( "value" ) === "";
2765}) ) {
2766 addHandle( "value", function( elem, name, isXML ) {
2767 if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2768 return elem.defaultValue;
2769 }
2770 });
2771}
2772
2773// Support: IE<9
2774// Use getAttributeNode to fetch booleans when getAttribute lies
2775if ( !assert(function( el ) {
2776 return el.getAttribute("disabled") == null;
2777}) ) {
2778 addHandle( booleans, function( elem, name, isXML ) {
2779 var val;
2780 if ( !isXML ) {
2781 return elem[ name ] === true ? name.toLowerCase() :
2782 (val = elem.getAttributeNode( name )) && val.specified ?
2783 val.value :
2784 null;
2785 }
2786 });
2787}
2788
2789return Sizzle;
2790
2791})( window );
2792
2793
2794
2795jQuery.find = Sizzle;
2796jQuery.expr = Sizzle.selectors;
2797
2798// Deprecated
2799jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2800jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2801jQuery.text = Sizzle.getText;
2802jQuery.isXMLDoc = Sizzle.isXML;
2803jQuery.contains = Sizzle.contains;
2804jQuery.escapeSelector = Sizzle.escape;
2805
2806
2807
2808
2809var dir = function( elem, dir, until ) {
2810 var matched = [],
2811 truncate = until !== undefined;
2812
2813 while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2814 if ( elem.nodeType === 1 ) {
2815 if ( truncate && jQuery( elem ).is( until ) ) {
2816 break;
2817 }
2818 matched.push( elem );
2819 }
2820 }
2821 return matched;
2822};
2823
2824
2825var siblings = function( n, elem ) {
2826 var matched = [];
2827
2828 for ( ; n; n = n.nextSibling ) {
2829 if ( n.nodeType === 1 && n !== elem ) {
2830 matched.push( n );
2831 }
2832 }
2833
2834 return matched;
2835};
2836
2837
2838var rneedsContext = jQuery.expr.match.needsContext;
2839
2840
2841
2842function nodeName( elem, name ) {
2843
2844 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
2845
2846};
2847var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
2848
2849
2850
2851var risSimple = /^.[^:#\[\.,]*$/;
2852
2853// Implement the identical functionality for filter and not
2854function winnow( elements, qualifier, not ) {
2855 if ( jQuery.isFunction( qualifier ) ) {
2856 return jQuery.grep( elements, function( elem, i ) {
2857 return !!qualifier.call( elem, i, elem ) !== not;
2858 } );
2859 }
2860
2861 // Single element
2862 if ( qualifier.nodeType ) {
2863 return jQuery.grep( elements, function( elem ) {
2864 return ( elem === qualifier ) !== not;
2865 } );
2866 }
2867
2868 // Arraylike of elements (jQuery, arguments, Array)
2869 if ( typeof qualifier !== "string" ) {
2870 return jQuery.grep( elements, function( elem ) {
2871 return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
2872 } );
2873 }
2874
2875 // Simple selector that can be filtered directly, removing non-Elements
2876 if ( risSimple.test( qualifier ) ) {
2877 return jQuery.filter( qualifier, elements, not );
2878 }
2879
2880 // Complex selector, compare the two sets, removing non-Elements
2881 qualifier = jQuery.filter( qualifier, elements );
2882 return jQuery.grep( elements, function( elem ) {
2883 return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
2884 } );
2885}
2886
2887jQuery.filter = function( expr, elems, not ) {
2888 var elem = elems[ 0 ];
2889
2890 if ( not ) {
2891 expr = ":not(" + expr + ")";
2892 }
2893
2894 if ( elems.length === 1 && elem.nodeType === 1 ) {
2895 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
2896 }
2897
2898 return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2899 return elem.nodeType === 1;
2900 } ) );
2901};
2902
2903jQuery.fn.extend( {
2904 find: function( selector ) {
2905 var i, ret,
2906 len = this.length,
2907 self = this;
2908
2909 if ( typeof selector !== "string" ) {
2910 return this.pushStack( jQuery( selector ).filter( function() {
2911 for ( i = 0; i < len; i++ ) {
2912 if ( jQuery.contains( self[ i ], this ) ) {
2913 return true;
2914 }
2915 }
2916 } ) );
2917 }
2918
2919 ret = this.pushStack( [] );
2920
2921 for ( i = 0; i < len; i++ ) {
2922 jQuery.find( selector, self[ i ], ret );
2923 }
2924
2925 return len > 1 ? jQuery.uniqueSort( ret ) : ret;
2926 },
2927 filter: function( selector ) {
2928 return this.pushStack( winnow( this, selector || [], false ) );
2929 },
2930 not: function( selector ) {
2931 return this.pushStack( winnow( this, selector || [], true ) );
2932 },
2933 is: function( selector ) {
2934 return !!winnow(
2935 this,
2936
2937 // If this is a positional/relative selector, check membership in the returned set
2938 // so $("p:first").is("p:last") won't return true for a doc with two "p".
2939 typeof selector === "string" && rneedsContext.test( selector ) ?
2940 jQuery( selector ) :
2941 selector || [],
2942 false
2943 ).length;
2944 }
2945} );
2946
2947
2948// Initialize a jQuery object
2949
2950
2951// A central reference to the root jQuery(document)
2952var rootjQuery,
2953
2954 // A simple way to check for HTML strings
2955 // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2956 // Strict HTML recognition (#11290: must start with <)
2957 // Shortcut simple #id case for speed
2958 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
2959
2960 init = jQuery.fn.init = function( selector, context, root ) {
2961 var match, elem;
2962
2963 // HANDLE: $(""), $(null), $(undefined), $(false)
2964 if ( !selector ) {
2965 return this;
2966 }
2967
2968 // Method init() accepts an alternate rootjQuery
2969 // so migrate can support jQuery.sub (gh-2101)
2970 root = root || rootjQuery;
2971
2972 // Handle HTML strings
2973 if ( typeof selector === "string" ) {
2974 if ( selector[ 0 ] === "<" &&
2975 selector[ selector.length - 1 ] === ">" &&
2976 selector.length >= 3 ) {
2977
2978 // Assume that strings that start and end with <> are HTML and skip the regex check
2979 match = [ null, selector, null ];
2980
2981 } else {
2982 match = rquickExpr.exec( selector );
2983 }
2984
2985 // Match html or make sure no context is specified for #id
2986 if ( match && ( match[ 1 ] || !context ) ) {
2987
2988 // HANDLE: $(html) -> $(array)
2989 if ( match[ 1 ] ) {
2990 context = context instanceof jQuery ? context[ 0 ] : context;
2991
2992 // Option to run scripts is true for back-compat
2993 // Intentionally let the error be thrown if parseHTML is not present
2994 jQuery.merge( this, jQuery.parseHTML(
2995 match[ 1 ],
2996 context && context.nodeType ? context.ownerDocument || context : document,
2997 true
2998 ) );
2999
3000 // HANDLE: $(html, props)
3001 if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
3002 for ( match in context ) {
3003
3004 // Properties of context are called as methods if possible
3005 if ( jQuery.isFunction( this[ match ] ) ) {
3006 this[ match ]( context[ match ] );
3007
3008 // ...and otherwise set as attributes
3009 } else {
3010 this.attr( match, context[ match ] );
3011 }
3012 }
3013 }
3014
3015 return this;
3016
3017 // HANDLE: $(#id)
3018 } else {
3019 elem = document.getElementById( match[ 2 ] );
3020
3021 if ( elem ) {
3022
3023 // Inject the element directly into the jQuery object
3024 this[ 0 ] = elem;
3025 this.length = 1;
3026 }
3027 return this;
3028 }
3029
3030 // HANDLE: $(expr, $(...))
3031 } else if ( !context || context.jquery ) {
3032 return ( context || root ).find( selector );
3033
3034 // HANDLE: $(expr, context)
3035 // (which is just equivalent to: $(context).find(expr)
3036 } else {
3037 return this.constructor( context ).find( selector );
3038 }
3039
3040 // HANDLE: $(DOMElement)
3041 } else if ( selector.nodeType ) {
3042 this[ 0 ] = selector;
3043 this.length = 1;
3044 return this;
3045
3046 // HANDLE: $(function)
3047 // Shortcut for document ready
3048 } else if ( jQuery.isFunction( selector ) ) {
3049 return root.ready !== undefined ?
3050 root.ready( selector ) :
3051
3052 // Execute immediately if ready is not present
3053 selector( jQuery );
3054 }
3055
3056 return jQuery.makeArray( selector, this );
3057 };
3058
3059// Give the init function the jQuery prototype for later instantiation
3060init.prototype = jQuery.fn;
3061
3062// Initialize central reference
3063rootjQuery = jQuery( document );
3064
3065
3066var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3067
3068 // Methods guaranteed to produce a unique set when starting from a unique set
3069 guaranteedUnique = {
3070 children: true,
3071 contents: true,
3072 next: true,
3073 prev: true
3074 };
3075
3076jQuery.fn.extend( {
3077 has: function( target ) {
3078 var targets = jQuery( target, this ),
3079 l = targets.length;
3080
3081 return this.filter( function() {
3082 var i = 0;
3083 for ( ; i < l; i++ ) {
3084 if ( jQuery.contains( this, targets[ i ] ) ) {
3085 return true;
3086 }
3087 }
3088 } );
3089 },
3090
3091 closest: function( selectors, context ) {
3092 var cur,
3093 i = 0,
3094 l = this.length,
3095 matched = [],
3096 targets = typeof selectors !== "string" && jQuery( selectors );
3097
3098 // Positional selectors never match, since there's no _selection_ context
3099 if ( !rneedsContext.test( selectors ) ) {
3100 for ( ; i < l; i++ ) {
3101 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
3102
3103 // Always skip document fragments
3104 if ( cur.nodeType < 11 && ( targets ?
3105 targets.index( cur ) > -1 :
3106
3107 // Don't pass non-elements to Sizzle
3108 cur.nodeType === 1 &&
3109 jQuery.find.matchesSelector( cur, selectors ) ) ) {
3110
3111 matched.push( cur );
3112 break;
3113 }
3114 }
3115 }
3116 }
3117
3118 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3119 },
3120
3121 // Determine the position of an element within the set
3122 index: function( elem ) {
3123
3124 // No argument, return index in parent
3125 if ( !elem ) {
3126 return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3127 }
3128
3129 // Index in selector
3130 if ( typeof elem === "string" ) {
3131 return indexOf.call( jQuery( elem ), this[ 0 ] );
3132 }
3133
3134 // Locate the position of the desired element
3135 return indexOf.call( this,
3136
3137 // If it receives a jQuery object, the first element is used
3138 elem.jquery ? elem[ 0 ] : elem
3139 );
3140 },
3141
3142 add: function( selector, context ) {
3143 return this.pushStack(
3144 jQuery.uniqueSort(
3145 jQuery.merge( this.get(), jQuery( selector, context ) )
3146 )
3147 );
3148 },
3149
3150 addBack: function( selector ) {
3151 return this.add( selector == null ?
3152 this.prevObject : this.prevObject.filter( selector )
3153 );
3154 }
3155} );
3156
3157function sibling( cur, dir ) {
3158 while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3159 return cur;
3160}
3161
3162jQuery.each( {
3163 parent: function( elem ) {
3164 var parent = elem.parentNode;
3165 return parent && parent.nodeType !== 11 ? parent : null;
3166 },
3167 parents: function( elem ) {
3168 return dir( elem, "parentNode" );
3169 },
3170 parentsUntil: function( elem, i, until ) {
3171 return dir( elem, "parentNode", until );
3172 },
3173 next: function( elem ) {
3174 return sibling( elem, "nextSibling" );
3175 },
3176 prev: function( elem ) {
3177 return sibling( elem, "previousSibling" );
3178 },
3179 nextAll: function( elem ) {
3180 return dir( elem, "nextSibling" );
3181 },
3182 prevAll: function( elem ) {
3183 return dir( elem, "previousSibling" );
3184 },
3185 nextUntil: function( elem, i, until ) {
3186 return dir( elem, "nextSibling", until );
3187 },
3188 prevUntil: function( elem, i, until ) {
3189 return dir( elem, "previousSibling", until );
3190 },
3191 siblings: function( elem ) {
3192 return siblings( ( elem.parentNode || {} ).firstChild, elem );
3193 },
3194 children: function( elem ) {
3195 return siblings( elem.firstChild );
3196 },
3197 contents: function( elem ) {
3198 if ( nodeName( elem, "iframe" ) ) {
3199 return elem.contentDocument;
3200 }
3201
3202 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
3203 // Treat the template element as a regular one in browsers that
3204 // don't support it.
3205 if ( nodeName( elem, "template" ) ) {
3206 elem = elem.content || elem;
3207 }
3208
3209 return jQuery.merge( [], elem.childNodes );
3210 }
3211}, function( name, fn ) {
3212 jQuery.fn[ name ] = function( until, selector ) {
3213 var matched = jQuery.map( this, fn, until );
3214
3215 if ( name.slice( -5 ) !== "Until" ) {
3216 selector = until;
3217 }
3218
3219 if ( selector && typeof selector === "string" ) {
3220 matched = jQuery.filter( selector, matched );
3221 }
3222
3223 if ( this.length > 1 ) {
3224
3225 // Remove duplicates
3226 if ( !guaranteedUnique[ name ] ) {
3227 jQuery.uniqueSort( matched );
3228 }
3229
3230 // Reverse order for parents* and prev-derivatives
3231 if ( rparentsprev.test( name ) ) {
3232 matched.reverse();
3233 }
3234 }
3235
3236 return this.pushStack( matched );
3237 };
3238} );
3239var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
3240
3241
3242
3243// Convert String-formatted options into Object-formatted ones
3244function createOptions( options ) {
3245 var object = {};
3246 jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
3247 object[ flag ] = true;
3248 } );
3249 return object;
3250}
3251
3252/*
3253 * Create a callback list using the following parameters:
3254 *
3255 * options: an optional list of space-separated options that will change how
3256 * the callback list behaves or a more traditional option object
3257 *
3258 * By default a callback list will act like an event callback list and can be
3259 * "fired" multiple times.
3260 *
3261 * Possible options:
3262 *
3263 * once: will ensure the callback list can only be fired once (like a Deferred)
3264 *
3265 * memory: will keep track of previous values and will call any callback added
3266 * after the list has been fired right away with the latest "memorized"
3267 * values (like a Deferred)
3268 *
3269 * unique: will ensure a callback can only be added once (no duplicate in the list)
3270 *
3271 * stopOnFalse: interrupt callings when a callback returns false
3272 *
3273 */
3274jQuery.Callbacks = function( options ) {
3275
3276 // Convert options from String-formatted to Object-formatted if needed
3277 // (we check in cache first)
3278 options = typeof options === "string" ?
3279 createOptions( options ) :
3280 jQuery.extend( {}, options );
3281
3282 var // Flag to know if list is currently firing
3283 firing,
3284
3285 // Last fire value for non-forgettable lists
3286 memory,
3287
3288 // Flag to know if list was already fired
3289 fired,
3290
3291 // Flag to prevent firing
3292 locked,
3293
3294 // Actual callback list
3295 list = [],
3296
3297 // Queue of execution data for repeatable lists
3298 queue = [],
3299
3300 // Index of currently firing callback (modified by add/remove as needed)
3301 firingIndex = -1,
3302
3303 // Fire callbacks
3304 fire = function() {
3305
3306 // Enforce single-firing
3307 locked = locked || options.once;
3308
3309 // Execute callbacks for all pending executions,
3310 // respecting firingIndex overrides and runtime changes
3311 fired = firing = true;
3312 for ( ; queue.length; firingIndex = -1 ) {
3313 memory = queue.shift();
3314 while ( ++firingIndex < list.length ) {
3315
3316 // Run callback and check for early termination
3317 if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3318 options.stopOnFalse ) {
3319
3320 // Jump to end and forget the data so .add doesn't re-fire
3321 firingIndex = list.length;
3322 memory = false;
3323 }
3324 }
3325 }
3326
3327 // Forget the data if we're done with it
3328 if ( !options.memory ) {
3329 memory = false;
3330 }
3331
3332 firing = false;
3333
3334 // Clean up if we're done firing for good
3335 if ( locked ) {
3336
3337 // Keep an empty list if we have data for future add calls
3338 if ( memory ) {
3339 list = [];
3340
3341 // Otherwise, this object is spent
3342 } else {
3343 list = "";
3344 }
3345 }
3346 },
3347
3348 // Actual Callbacks object
3349 self = {
3350
3351 // Add a callback or a collection of callbacks to the list
3352 add: function() {
3353 if ( list ) {
3354
3355 // If we have memory from a past run, we should fire after adding
3356 if ( memory && !firing ) {
3357 firingIndex = list.length - 1;
3358 queue.push( memory );
3359 }
3360
3361 ( function add( args ) {
3362 jQuery.each( args, function( _, arg ) {
3363 if ( jQuery.isFunction( arg ) ) {
3364 if ( !options.unique || !self.has( arg ) ) {
3365 list.push( arg );
3366 }
3367 } else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
3368
3369 // Inspect recursively
3370 add( arg );
3371 }
3372 } );
3373 } )( arguments );
3374
3375 if ( memory && !firing ) {
3376 fire();
3377 }
3378 }
3379 return this;
3380 },
3381
3382 // Remove a callback from the list
3383 remove: function() {
3384 jQuery.each( arguments, function( _, arg ) {
3385 var index;
3386 while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3387 list.splice( index, 1 );
3388
3389 // Handle firing indexes
3390 if ( index <= firingIndex ) {
3391 firingIndex--;
3392 }
3393 }
3394 } );
3395 return this;
3396 },
3397
3398 // Check if a given callback is in the list.
3399 // If no argument is given, return whether or not list has callbacks attached.
3400 has: function( fn ) {
3401 return fn ?
3402 jQuery.inArray( fn, list ) > -1 :
3403 list.length > 0;
3404 },
3405
3406 // Remove all callbacks from the list
3407 empty: function() {
3408 if ( list ) {
3409 list = [];
3410 }
3411 return this;
3412 },
3413
3414 // Disable .fire and .add
3415 // Abort any current/pending executions
3416 // Clear all callbacks and values
3417 disable: function() {
3418 locked = queue = [];
3419 list = memory = "";
3420 return this;
3421 },
3422 disabled: function() {
3423 return !list;
3424 },
3425
3426 // Disable .fire
3427 // Also disable .add unless we have memory (since it would have no effect)
3428 // Abort any pending executions
3429 lock: function() {
3430 locked = queue = [];
3431 if ( !memory && !firing ) {
3432 list = memory = "";
3433 }
3434 return this;
3435 },
3436 locked: function() {
3437 return !!locked;
3438 },
3439
3440 // Call all callbacks with the given context and arguments
3441 fireWith: function( context, args ) {
3442 if ( !locked ) {
3443 args = args || [];
3444 args = [ context, args.slice ? args.slice() : args ];
3445 queue.push( args );
3446 if ( !firing ) {
3447 fire();
3448 }
3449 }
3450 return this;
3451 },
3452
3453 // Call all the callbacks with the given arguments
3454 fire: function() {
3455 self.fireWith( this, arguments );
3456 return this;
3457 },
3458
3459 // To know if the callbacks have already been called at least once
3460 fired: function() {
3461 return !!fired;
3462 }
3463 };
3464
3465 return self;
3466};
3467
3468
3469function Identity( v ) {
3470 return v;
3471}
3472function Thrower( ex ) {
3473 throw ex;
3474}
3475
3476function adoptValue( value, resolve, reject, noValue ) {
3477 var method;
3478
3479 try {
3480
3481 // Check for promise aspect first to privilege synchronous behavior
3482 if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
3483 method.call( value ).done( resolve ).fail( reject );
3484
3485 // Other thenables
3486 } else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
3487 method.call( value, resolve, reject );
3488
3489 // Other non-thenables
3490 } else {
3491
3492 // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
3493 // * false: [ value ].slice( 0 ) => resolve( value )
3494 // * true: [ value ].slice( 1 ) => resolve()
3495 resolve.apply( undefined, [ value ].slice( noValue ) );
3496 }
3497
3498 // For Promises/A+, convert exceptions into rejections
3499 // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
3500 // Deferred#then to conditionally suppress rejection.
3501 } catch ( value ) {
3502
3503 // Support: Android 4.0 only
3504 // Strict mode functions invoked without .call/.apply get global-object context
3505 reject.apply( undefined, [ value ] );
3506 }
3507}
3508
3509jQuery.extend( {
3510
3511 Deferred: function( func ) {
3512 var tuples = [
3513
3514 // action, add listener, callbacks,
3515 // ... .then handlers, argument index, [final state]
3516 [ "notify", "progress", jQuery.Callbacks( "memory" ),
3517 jQuery.Callbacks( "memory" ), 2 ],
3518 [ "resolve", "done", jQuery.Callbacks( "once memory" ),
3519 jQuery.Callbacks( "once memory" ), 0, "resolved" ],
3520 [ "reject", "fail", jQuery.Callbacks( "once memory" ),
3521 jQuery.Callbacks( "once memory" ), 1, "rejected" ]
3522 ],
3523 state = "pending",
3524 promise = {
3525 state: function() {
3526 return state;
3527 },
3528 always: function() {
3529 deferred.done( arguments ).fail( arguments );
3530 return this;
3531 },
3532 "catch": function( fn ) {
3533 return promise.then( null, fn );
3534 },
3535
3536 // Keep pipe for back-compat
3537 pipe: function( /* fnDone, fnFail, fnProgress */ ) {
3538 var fns = arguments;
3539
3540 return jQuery.Deferred( function( newDefer ) {
3541 jQuery.each( tuples, function( i, tuple ) {
3542
3543 // Map tuples (progress, done, fail) to arguments (done, fail, progress)
3544 var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
3545
3546 // deferred.progress(function() { bind to newDefer or newDefer.notify })
3547 // deferred.done(function() { bind to newDefer or newDefer.resolve })
3548 // deferred.fail(function() { bind to newDefer or newDefer.reject })
3549 deferred[ tuple[ 1 ] ]( function() {
3550 var returned = fn && fn.apply( this, arguments );
3551 if ( returned && jQuery.isFunction( returned.promise ) ) {
3552 returned.promise()
3553 .progress( newDefer.notify )
3554 .done( newDefer.resolve )
3555 .fail( newDefer.reject );
3556 } else {
3557 newDefer[ tuple[ 0 ] + "With" ](
3558 this,
3559 fn ? [ returned ] : arguments
3560 );
3561 }
3562 } );
3563 } );
3564 fns = null;
3565 } ).promise();
3566 },
3567 then: function( onFulfilled, onRejected, onProgress ) {
3568 var maxDepth = 0;
3569 function resolve( depth, deferred, handler, special ) {
3570 return function() {
3571 var that = this,
3572 args = arguments,
3573 mightThrow = function() {
3574 var returned, then;
3575
3576 // Support: Promises/A+ section 2.3.3.3.3
3577 // https://promisesaplus.com/#point-59
3578 // Ignore double-resolution attempts
3579 if ( depth < maxDepth ) {
3580 return;
3581 }
3582
3583 returned = handler.apply( that, args );
3584
3585 // Support: Promises/A+ section 2.3.1
3586 // https://promisesaplus.com/#point-48
3587 if ( returned === deferred.promise() ) {
3588 throw new TypeError( "Thenable self-resolution" );
3589 }
3590
3591 // Support: Promises/A+ sections 2.3.3.1, 3.5
3592 // https://promisesaplus.com/#point-54
3593 // https://promisesaplus.com/#point-75
3594 // Retrieve `then` only once
3595 then = returned &&
3596
3597 // Support: Promises/A+ section 2.3.4
3598 // https://promisesaplus.com/#point-64
3599 // Only check objects and functions for thenability
3600 ( typeof returned === "object" ||
3601 typeof returned === "function" ) &&
3602 returned.then;
3603
3604 // Handle a returned thenable
3605 if ( jQuery.isFunction( then ) ) {
3606
3607 // Special processors (notify) just wait for resolution
3608 if ( special ) {
3609 then.call(
3610 returned,
3611 resolve( maxDepth, deferred, Identity, special ),
3612 resolve( maxDepth, deferred, Thrower, special )
3613 );
3614
3615 // Normal processors (resolve) also hook into progress
3616 } else {
3617
3618 // ...and disregard older resolution values
3619 maxDepth++;
3620
3621 then.call(
3622 returned,
3623 resolve( maxDepth, deferred, Identity, special ),
3624 resolve( maxDepth, deferred, Thrower, special ),
3625 resolve( maxDepth, deferred, Identity,
3626 deferred.notifyWith )
3627 );
3628 }
3629
3630 // Handle all other returned values
3631 } else {
3632
3633 // Only substitute handlers pass on context
3634 // and multiple values (non-spec behavior)
3635 if ( handler !== Identity ) {
3636 that = undefined;
3637 args = [ returned ];
3638 }
3639
3640 // Process the value(s)
3641 // Default process is resolve
3642 ( special || deferred.resolveWith )( that, args );
3643 }
3644 },
3645
3646 // Only normal processors (resolve) catch and reject exceptions
3647 process = special ?
3648 mightThrow :
3649 function() {
3650 try {
3651 mightThrow();
3652 } catch ( e ) {
3653
3654 if ( jQuery.Deferred.exceptionHook ) {
3655 jQuery.Deferred.exceptionHook( e,
3656 process.stackTrace );
3657 }
3658
3659 // Support: Promises/A+ section 2.3.3.3.4.1
3660 // https://promisesaplus.com/#point-61
3661 // Ignore post-resolution exceptions
3662 if ( depth + 1 >= maxDepth ) {
3663
3664 // Only substitute handlers pass on context
3665 // and multiple values (non-spec behavior)
3666 if ( handler !== Thrower ) {
3667 that = undefined;
3668 args = [ e ];
3669 }
3670
3671 deferred.rejectWith( that, args );
3672 }
3673 }
3674 };
3675
3676 // Support: Promises/A+ section 2.3.3.3.1
3677 // https://promisesaplus.com/#point-57
3678 // Re-resolve promises immediately to dodge false rejection from
3679 // subsequent errors
3680 if ( depth ) {
3681 process();
3682 } else {
3683
3684 // Call an optional hook to record the stack, in case of exception
3685 // since it's otherwise lost when execution goes async
3686 if ( jQuery.Deferred.getStackHook ) {
3687 process.stackTrace = jQuery.Deferred.getStackHook();
3688 }
3689 window.setTimeout( process );
3690 }
3691 };
3692 }
3693
3694 return jQuery.Deferred( function( newDefer ) {
3695
3696 // progress_handlers.add( ... )
3697 tuples[ 0 ][ 3 ].add(
3698 resolve(
3699 0,
3700 newDefer,
3701 jQuery.isFunction( onProgress ) ?
3702 onProgress :
3703 Identity,
3704 newDefer.notifyWith
3705 )
3706 );
3707
3708 // fulfilled_handlers.add( ... )
3709 tuples[ 1 ][ 3 ].add(
3710 resolve(
3711 0,
3712 newDefer,
3713 jQuery.isFunction( onFulfilled ) ?
3714 onFulfilled :
3715 Identity
3716 )
3717 );
3718
3719 // rejected_handlers.add( ... )
3720 tuples[ 2 ][ 3 ].add(
3721 resolve(
3722 0,
3723 newDefer,
3724 jQuery.isFunction( onRejected ) ?
3725 onRejected :
3726 Thrower
3727 )
3728 );
3729 } ).promise();
3730 },
3731
3732 // Get a promise for this deferred
3733 // If obj is provided, the promise aspect is added to the object
3734 promise: function( obj ) {
3735 return obj != null ? jQuery.extend( obj, promise ) : promise;
3736 }
3737 },
3738 deferred = {};
3739
3740 // Add list-specific methods
3741 jQuery.each( tuples, function( i, tuple ) {
3742 var list = tuple[ 2 ],
3743 stateString = tuple[ 5 ];
3744
3745 // promise.progress = list.add
3746 // promise.done = list.add
3747 // promise.fail = list.add
3748 promise[ tuple[ 1 ] ] = list.add;
3749
3750 // Handle state
3751 if ( stateString ) {
3752 list.add(
3753 function() {
3754
3755 // state = "resolved" (i.e., fulfilled)
3756 // state = "rejected"
3757 state = stateString;
3758 },
3759
3760 // rejected_callbacks.disable
3761 // fulfilled_callbacks.disable
3762 tuples[ 3 - i ][ 2 ].disable,
3763
3764 // progress_callbacks.lock
3765 tuples[ 0 ][ 2 ].lock
3766 );
3767 }
3768
3769 // progress_handlers.fire
3770 // fulfilled_handlers.fire
3771 // rejected_handlers.fire
3772 list.add( tuple[ 3 ].fire );
3773
3774 // deferred.notify = function() { deferred.notifyWith(...) }
3775 // deferred.resolve = function() { deferred.resolveWith(...) }
3776 // deferred.reject = function() { deferred.rejectWith(...) }
3777 deferred[ tuple[ 0 ] ] = function() {
3778 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
3779 return this;
3780 };
3781
3782 // deferred.notifyWith = list.fireWith
3783 // deferred.resolveWith = list.fireWith
3784 // deferred.rejectWith = list.fireWith
3785 deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3786 } );
3787
3788 // Make the deferred a promise
3789 promise.promise( deferred );
3790
3791 // Call given func if any
3792 if ( func ) {
3793 func.call( deferred, deferred );
3794 }
3795
3796 // All done!
3797 return deferred;
3798 },
3799
3800 // Deferred helper
3801 when: function( singleValue ) {
3802 var
3803
3804 // count of uncompleted subordinates
3805 remaining = arguments.length,
3806
3807 // count of unprocessed arguments
3808 i = remaining,
3809
3810 // subordinate fulfillment data
3811 resolveContexts = Array( i ),
3812 resolveValues = slice.call( arguments ),
3813
3814 // the master Deferred
3815 master = jQuery.Deferred(),
3816
3817 // subordinate callback factory
3818 updateFunc = function( i ) {
3819 return function( value ) {
3820 resolveContexts[ i ] = this;
3821 resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
3822 if ( !( --remaining ) ) {
3823 master.resolveWith( resolveContexts, resolveValues );
3824 }
3825 };
3826 };
3827
3828 // Single- and empty arguments are adopted like Promise.resolve
3829 if ( remaining <= 1 ) {
3830 adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
3831 !remaining );
3832
3833 // Use .then() to unwrap secondary thenables (cf. gh-3000)
3834 if ( master.state() === "pending" ||
3835 jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
3836
3837 return master.then();
3838 }
3839 }
3840
3841 // Multiple arguments are aggregated like Promise.all array elements
3842 while ( i-- ) {
3843 adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
3844 }
3845
3846 return master.promise();
3847 }
3848} );
3849
3850
3851// These usually indicate a programmer mistake during development,
3852// warn about them ASAP rather than swallowing them by default.
3853var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
3854
3855jQuery.Deferred.exceptionHook = function( error, stack ) {
3856
3857 // Support: IE 8 - 9 only
3858 // Console exists when dev tools are open, which can happen at any time
3859 if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
3860 window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
3861 }
3862};
3863
3864
3865
3866
3867jQuery.readyException = function( error ) {
3868 window.setTimeout( function() {
3869 throw error;
3870 } );
3871};
3872
3873
3874
3875
3876// The deferred used on DOM ready
3877var readyList = jQuery.Deferred();
3878
3879jQuery.fn.ready = function( fn ) {
3880
3881 readyList
3882 .then( fn )
3883
3884 // Wrap jQuery.readyException in a function so that the lookup
3885 // happens at the time of error handling instead of callback
3886 // registration.
3887 .catch( function( error ) {
3888 jQuery.readyException( error );
3889 } );
3890
3891 return this;
3892};
3893
3894jQuery.extend( {
3895
3896 // Is the DOM ready to be used? Set to true once it occurs.
3897 isReady: false,
3898
3899 // A counter to track how many items to wait for before
3900 // the ready event fires. See #6781
3901 readyWait: 1,
3902
3903 // Handle when the DOM is ready
3904 ready: function( wait ) {
3905
3906 // Abort if there are pending holds or we're already ready
3907 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
3908 return;
3909 }
3910
3911 // Remember that the DOM is ready
3912 jQuery.isReady = true;
3913
3914 // If a normal DOM Ready event fired, decrement, and wait if need be
3915 if ( wait !== true && --jQuery.readyWait > 0 ) {
3916 return;
3917 }
3918
3919 // If there are functions bound, to execute
3920 readyList.resolveWith( document, [ jQuery ] );
3921 }
3922} );
3923
3924jQuery.ready.then = readyList.then;
3925
3926// The ready event handler and self cleanup method
3927function completed() {
3928 document.removeEventListener( "DOMContentLoaded", completed );
3929 window.removeEventListener( "load", completed );
3930 jQuery.ready();
3931}
3932
3933// Catch cases where $(document).ready() is called
3934// after the browser event has already occurred.
3935// Support: IE <=9 - 10 only
3936// Older IE sometimes signals "interactive" too soon
3937if ( document.readyState === "complete" ||
3938 ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
3939
3940 // Handle it asynchronously to allow scripts the opportunity to delay ready
3941 window.setTimeout( jQuery.ready );
3942
3943} else {
3944
3945 // Use the handy event callback
3946 document.addEventListener( "DOMContentLoaded", completed );
3947
3948 // A fallback to window.onload, that will always work
3949 window.addEventListener( "load", completed );
3950}
3951
3952
3953
3954
3955// Multifunctional method to get and set values of a collection
3956// The value/s can optionally be executed if it's a function
3957var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
3958 var i = 0,
3959 len = elems.length,
3960 bulk = key == null;
3961
3962 // Sets many values
3963 if ( jQuery.type( key ) === "object" ) {
3964 chainable = true;
3965 for ( i in key ) {
3966 access( elems, fn, i, key[ i ], true, emptyGet, raw );
3967 }
3968
3969 // Sets one value
3970 } else if ( value !== undefined ) {
3971 chainable = true;
3972
3973 if ( !jQuery.isFunction( value ) ) {
3974 raw = true;
3975 }
3976
3977 if ( bulk ) {
3978
3979 // Bulk operations run against the entire set
3980 if ( raw ) {
3981 fn.call( elems, value );
3982 fn = null;
3983
3984 // ...except when executing function values
3985 } else {
3986 bulk = fn;
3987 fn = function( elem, key, value ) {
3988 return bulk.call( jQuery( elem ), value );
3989 };
3990 }
3991 }
3992
3993 if ( fn ) {
3994 for ( ; i < len; i++ ) {
3995 fn(
3996 elems[ i ], key, raw ?
3997 value :
3998 value.call( elems[ i ], i, fn( elems[ i ], key ) )
3999 );
4000 }
4001 }
4002 }
4003
4004 if ( chainable ) {
4005 return elems;
4006 }
4007
4008 // Gets
4009 if ( bulk ) {
4010 return fn.call( elems );
4011 }
4012
4013 return len ? fn( elems[ 0 ], key ) : emptyGet;
4014};
4015var acceptData = function( owner ) {
4016
4017 // Accepts only:
4018 // - Node
4019 // - Node.ELEMENT_NODE
4020 // - Node.DOCUMENT_NODE
4021 // - Object
4022 // - Any
4023 return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
4024};
4025
4026
4027
4028
4029function Data() {
4030 this.expando = jQuery.expando + Data.uid++;
4031}
4032
4033Data.uid = 1;
4034
4035Data.prototype = {
4036
4037 cache: function( owner ) {
4038
4039 // Check if the owner object already has a cache
4040 var value = owner[ this.expando ];
4041
4042 // If not, create one
4043 if ( !value ) {
4044 value = {};
4045
4046 // We can accept data for non-element nodes in modern browsers,
4047 // but we should not, see #8335.
4048 // Always return an empty object.
4049 if ( acceptData( owner ) ) {
4050
4051 // If it is a node unlikely to be stringify-ed or looped over
4052 // use plain assignment
4053 if ( owner.nodeType ) {
4054 owner[ this.expando ] = value;
4055
4056 // Otherwise secure it in a non-enumerable property
4057 // configurable must be true to allow the property to be
4058 // deleted when data is removed
4059 } else {
4060 Object.defineProperty( owner, this.expando, {
4061 value: value,
4062 configurable: true
4063 } );
4064 }
4065 }
4066 }
4067
4068 return value;
4069 },
4070 set: function( owner, data, value ) {
4071 var prop,
4072 cache = this.cache( owner );
4073
4074 // Handle: [ owner, key, value ] args
4075 // Always use camelCase key (gh-2257)
4076 if ( typeof data === "string" ) {
4077 cache[ jQuery.camelCase( data ) ] = value;
4078
4079 // Handle: [ owner, { properties } ] args
4080 } else {
4081
4082 // Copy the properties one-by-one to the cache object
4083 for ( prop in data ) {
4084 cache[ jQuery.camelCase( prop ) ] = data[ prop ];
4085 }
4086 }
4087 return cache;
4088 },
4089 get: function( owner, key ) {
4090 return key === undefined ?
4091 this.cache( owner ) :
4092
4093 // Always use camelCase key (gh-2257)
4094 owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
4095 },
4096 access: function( owner, key, value ) {
4097
4098 // In cases where either:
4099 //
4100 // 1. No key was specified
4101 // 2. A string key was specified, but no value provided
4102 //
4103 // Take the "read" path and allow the get method to determine
4104 // which value to return, respectively either:
4105 //
4106 // 1. The entire cache object
4107 // 2. The data stored at the key
4108 //
4109 if ( key === undefined ||
4110 ( ( key && typeof key === "string" ) && value === undefined ) ) {
4111
4112 return this.get( owner, key );
4113 }
4114
4115 // When the key is not a string, or both a key and value
4116 // are specified, set or extend (existing objects) with either:
4117 //
4118 // 1. An object of properties
4119 // 2. A key and value
4120 //
4121 this.set( owner, key, value );
4122
4123 // Since the "set" path can have two possible entry points
4124 // return the expected data based on which path was taken[*]
4125 return value !== undefined ? value : key;
4126 },
4127 remove: function( owner, key ) {
4128 var i,
4129 cache = owner[ this.expando ];
4130
4131 if ( cache === undefined ) {
4132 return;
4133 }
4134
4135 if ( key !== undefined ) {
4136
4137 // Support array or space separated string of keys
4138 if ( Array.isArray( key ) ) {
4139
4140 // If key is an array of keys...
4141 // We always set camelCase keys, so remove that.
4142 key = key.map( jQuery.camelCase );
4143 } else {
4144 key = jQuery.camelCase( key );
4145
4146 // If a key with the spaces exists, use it.
4147 // Otherwise, create an array by matching non-whitespace
4148 key = key in cache ?
4149 [ key ] :
4150 ( key.match( rnothtmlwhite ) || [] );
4151 }
4152
4153 i = key.length;
4154
4155 while ( i-- ) {
4156 delete cache[ key[ i ] ];
4157 }
4158 }
4159
4160 // Remove the expando if there's no more data
4161 if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
4162
4163 // Support: Chrome <=35 - 45
4164 // Webkit & Blink performance suffers when deleting properties
4165 // from DOM nodes, so set to undefined instead
4166 // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
4167 if ( owner.nodeType ) {
4168 owner[ this.expando ] = undefined;
4169 } else {
4170 delete owner[ this.expando ];
4171 }
4172 }
4173 },
4174 hasData: function( owner ) {
4175 var cache = owner[ this.expando ];
4176 return cache !== undefined && !jQuery.isEmptyObject( cache );
4177 }
4178};
4179var dataPriv = new Data();
4180
4181var dataUser = new Data();
4182
4183
4184
4185// Implementation Summary
4186//
4187// 1. Enforce API surface and semantic compatibility with 1.9.x branch
4188// 2. Improve the module's maintainability by reducing the storage
4189// paths to a single mechanism.
4190// 3. Use the same single mechanism to support "private" and "user" data.
4191// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4192// 5. Avoid exposing implementation details on user objects (eg. expando properties)
4193// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
4194
4195var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
4196 rmultiDash = /[A-Z]/g;
4197
4198function getData( data ) {
4199 if ( data === "true" ) {
4200 return true;
4201 }
4202
4203 if ( data === "false" ) {
4204 return false;
4205 }
4206
4207 if ( data === "null" ) {
4208 return null;
4209 }
4210
4211 // Only convert to a number if it doesn't change the string
4212 if ( data === +data + "" ) {
4213 return +data;
4214 }
4215
4216 if ( rbrace.test( data ) ) {
4217 return JSON.parse( data );
4218 }
4219
4220 return data;
4221}
4222
4223function dataAttr( elem, key, data ) {
4224 var name;
4225
4226 // If nothing was found internally, try to fetch any
4227 // data from the HTML5 data-* attribute
4228 if ( data === undefined && elem.nodeType === 1 ) {
4229 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
4230 data = elem.getAttribute( name );
4231
4232 if ( typeof data === "string" ) {
4233 try {
4234 data = getData( data );
4235 } catch ( e ) {}
4236
4237 // Make sure we set the data so it isn't changed later
4238 dataUser.set( elem, key, data );
4239 } else {
4240 data = undefined;
4241 }
4242 }
4243 return data;
4244}
4245
4246jQuery.extend( {
4247 hasData: function( elem ) {
4248 return dataUser.hasData( elem ) || dataPriv.hasData( elem );
4249 },
4250
4251 data: function( elem, name, data ) {
4252 return dataUser.access( elem, name, data );
4253 },
4254
4255 removeData: function( elem, name ) {
4256 dataUser.remove( elem, name );
4257 },
4258
4259 // TODO: Now that all calls to _data and _removeData have been replaced
4260 // with direct calls to dataPriv methods, these can be deprecated.
4261 _data: function( elem, name, data ) {
4262 return dataPriv.access( elem, name, data );
4263 },
4264
4265 _removeData: function( elem, name ) {
4266 dataPriv.remove( elem, name );
4267 }
4268} );
4269
4270jQuery.fn.extend( {
4271 data: function( key, value ) {
4272 var i, name, data,
4273 elem = this[ 0 ],
4274 attrs = elem && elem.attributes;
4275
4276 // Gets all values
4277 if ( key === undefined ) {
4278 if ( this.length ) {
4279 data = dataUser.get( elem );
4280
4281 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
4282 i = attrs.length;
4283 while ( i-- ) {
4284
4285 // Support: IE 11 only
4286 // The attrs elements can be null (#14894)
4287 if ( attrs[ i ] ) {
4288 name = attrs[ i ].name;
4289 if ( name.indexOf( "data-" ) === 0 ) {
4290 name = jQuery.camelCase( name.slice( 5 ) );
4291 dataAttr( elem, name, data[ name ] );
4292 }
4293 }
4294 }
4295 dataPriv.set( elem, "hasDataAttrs", true );
4296 }
4297 }
4298
4299 return data;
4300 }
4301
4302 // Sets multiple values
4303 if ( typeof key === "object" ) {
4304 return this.each( function() {
4305 dataUser.set( this, key );
4306 } );
4307 }
4308
4309 return access( this, function( value ) {
4310 var data;
4311
4312 // The calling jQuery object (element matches) is not empty
4313 // (and therefore has an element appears at this[ 0 ]) and the
4314 // `value` parameter was not undefined. An empty jQuery object
4315 // will result in `undefined` for elem = this[ 0 ] which will
4316 // throw an exception if an attempt to read a data cache is made.
4317 if ( elem && value === undefined ) {
4318
4319 // Attempt to get data from the cache
4320 // The key will always be camelCased in Data
4321 data = dataUser.get( elem, key );
4322 if ( data !== undefined ) {
4323 return data;
4324 }
4325
4326 // Attempt to "discover" the data in
4327 // HTML5 custom data-* attrs
4328 data = dataAttr( elem, key );
4329 if ( data !== undefined ) {
4330 return data;
4331 }
4332
4333 // We tried really hard, but the data doesn't exist.
4334 return;
4335 }
4336
4337 // Set the data...
4338 this.each( function() {
4339
4340 // We always store the camelCased key
4341 dataUser.set( this, key, value );
4342 } );
4343 }, null, value, arguments.length > 1, null, true );
4344 },
4345
4346 removeData: function( key ) {
4347 return this.each( function() {
4348 dataUser.remove( this, key );
4349 } );
4350 }
4351} );
4352
4353
4354jQuery.extend( {
4355 queue: function( elem, type, data ) {
4356 var queue;
4357
4358 if ( elem ) {
4359 type = ( type || "fx" ) + "queue";
4360 queue = dataPriv.get( elem, type );
4361
4362 // Speed up dequeue by getting out quickly if this is just a lookup
4363 if ( data ) {
4364 if ( !queue || Array.isArray( data ) ) {
4365 queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
4366 } else {
4367 queue.push( data );
4368 }
4369 }
4370 return queue || [];
4371 }
4372 },
4373
4374 dequeue: function( elem, type ) {
4375 type = type || "fx";
4376
4377 var queue = jQuery.queue( elem, type ),
4378 startLength = queue.length,
4379 fn = queue.shift(),
4380 hooks = jQuery._queueHooks( elem, type ),
4381 next = function() {
4382 jQuery.dequeue( elem, type );
4383 };
4384
4385 // If the fx queue is dequeued, always remove the progress sentinel
4386 if ( fn === "inprogress" ) {
4387 fn = queue.shift();
4388 startLength--;
4389 }
4390
4391 if ( fn ) {
4392
4393 // Add a progress sentinel to prevent the fx queue from being
4394 // automatically dequeued
4395 if ( type === "fx" ) {
4396 queue.unshift( "inprogress" );
4397 }
4398
4399 // Clear up the last queue stop function
4400 delete hooks.stop;
4401 fn.call( elem, next, hooks );
4402 }
4403
4404 if ( !startLength && hooks ) {
4405 hooks.empty.fire();
4406 }
4407 },
4408
4409 // Not public - generate a queueHooks object, or return the current one
4410 _queueHooks: function( elem, type ) {
4411 var key = type + "queueHooks";
4412 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
4413 empty: jQuery.Callbacks( "once memory" ).add( function() {
4414 dataPriv.remove( elem, [ type + "queue", key ] );
4415 } )
4416 } );
4417 }
4418} );
4419
4420jQuery.fn.extend( {
4421 queue: function( type, data ) {
4422 var setter = 2;
4423
4424 if ( typeof type !== "string" ) {
4425 data = type;
4426 type = "fx";
4427 setter--;
4428 }
4429
4430 if ( arguments.length < setter ) {
4431 return jQuery.queue( this[ 0 ], type );
4432 }
4433
4434 return data === undefined ?
4435 this :
4436 this.each( function() {
4437 var queue = jQuery.queue( this, type, data );
4438
4439 // Ensure a hooks for this queue
4440 jQuery._queueHooks( this, type );
4441
4442 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4443 jQuery.dequeue( this, type );
4444 }
4445 } );
4446 },
4447 dequeue: function( type ) {
4448 return this.each( function() {
4449 jQuery.dequeue( this, type );
4450 } );
4451 },
4452 clearQueue: function( type ) {
4453 return this.queue( type || "fx", [] );
4454 },
4455
4456 // Get a promise resolved when queues of a certain type
4457 // are emptied (fx is the type by default)
4458 promise: function( type, obj ) {
4459 var tmp,
4460 count = 1,
4461 defer = jQuery.Deferred(),
4462 elements = this,
4463 i = this.length,
4464 resolve = function() {
4465 if ( !( --count ) ) {
4466 defer.resolveWith( elements, [ elements ] );
4467 }
4468 };
4469
4470 if ( typeof type !== "string" ) {
4471 obj = type;
4472 type = undefined;
4473 }
4474 type = type || "fx";
4475
4476 while ( i-- ) {
4477 tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
4478 if ( tmp && tmp.empty ) {
4479 count++;
4480 tmp.empty.add( resolve );
4481 }
4482 }
4483 resolve();
4484 return defer.promise( obj );
4485 }
4486} );
4487var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4488
4489var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4490
4491
4492var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4493
4494var isHiddenWithinTree = function( elem, el ) {
4495
4496 // isHiddenWithinTree might be called from jQuery#filter function;
4497 // in that case, element will be second argument
4498 elem = el || elem;
4499
4500 // Inline style trumps all
4501 return elem.style.display === "none" ||
4502 elem.style.display === "" &&
4503
4504 // Otherwise, check computed style
4505 // Support: Firefox <=43 - 45
4506 // Disconnected elements can have computed display: none, so first confirm that elem is
4507 // in the document.
4508 jQuery.contains( elem.ownerDocument, elem ) &&
4509
4510 jQuery.css( elem, "display" ) === "none";
4511 };
4512
4513var swap = function( elem, options, callback, args ) {
4514 var ret, name,
4515 old = {};
4516
4517 // Remember the old values, and insert the new ones
4518 for ( name in options ) {
4519 old[ name ] = elem.style[ name ];
4520 elem.style[ name ] = options[ name ];
4521 }
4522
4523 ret = callback.apply( elem, args || [] );
4524
4525 // Revert the old values
4526 for ( name in options ) {
4527 elem.style[ name ] = old[ name ];
4528 }
4529
4530 return ret;
4531};
4532
4533
4534
4535
4536function adjustCSS( elem, prop, valueParts, tween ) {
4537 var adjusted,
4538 scale = 1,
4539 maxIterations = 20,
4540 currentValue = tween ?
4541 function() {
4542 return tween.cur();
4543 } :
4544 function() {
4545 return jQuery.css( elem, prop, "" );
4546 },
4547 initial = currentValue(),
4548 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4549
4550 // Starting value computation is required for potential unit mismatches
4551 initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4552 rcssNum.exec( jQuery.css( elem, prop ) );
4553
4554 if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4555
4556 // Trust units reported by jQuery.css
4557 unit = unit || initialInUnit[ 3 ];
4558
4559 // Make sure we update the tween properties later on
4560 valueParts = valueParts || [];
4561
4562 // Iteratively approximate from a nonzero starting point
4563 initialInUnit = +initial || 1;
4564
4565 do {
4566
4567 // If previous iteration zeroed out, double until we get *something*.
4568 // Use string for doubling so we don't accidentally see scale as unchanged below
4569 scale = scale || ".5";
4570
4571 // Adjust and apply
4572 initialInUnit = initialInUnit / scale;
4573 jQuery.style( elem, prop, initialInUnit + unit );
4574
4575 // Update scale, tolerating zero or NaN from tween.cur()
4576 // Break the loop if scale is unchanged or perfect, or if we've just had enough.
4577 } while (
4578 scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
4579 );
4580 }
4581
4582 if ( valueParts ) {
4583 initialInUnit = +initialInUnit || +initial || 0;
4584
4585 // Apply relative offset (+=/-=) if specified
4586 adjusted = valueParts[ 1 ] ?
4587 initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4588 +valueParts[ 2 ];
4589 if ( tween ) {
4590 tween.unit = unit;
4591 tween.start = initialInUnit;
4592 tween.end = adjusted;
4593 }
4594 }
4595 return adjusted;
4596}
4597
4598
4599var defaultDisplayMap = {};
4600
4601function getDefaultDisplay( elem ) {
4602 var temp,
4603 doc = elem.ownerDocument,
4604 nodeName = elem.nodeName,
4605 display = defaultDisplayMap[ nodeName ];
4606
4607 if ( display ) {
4608 return display;
4609 }
4610
4611 temp = doc.body.appendChild( doc.createElement( nodeName ) );
4612 display = jQuery.css( temp, "display" );
4613
4614 temp.parentNode.removeChild( temp );
4615
4616 if ( display === "none" ) {
4617 display = "block";
4618 }
4619 defaultDisplayMap[ nodeName ] = display;
4620
4621 return display;
4622}
4623
4624function showHide( elements, show ) {
4625 var display, elem,
4626 values = [],
4627 index = 0,
4628 length = elements.length;
4629
4630 // Determine new display value for elements that need to change
4631 for ( ; index < length; index++ ) {
4632 elem = elements[ index ];
4633 if ( !elem.style ) {
4634 continue;
4635 }
4636
4637 display = elem.style.display;
4638 if ( show ) {
4639
4640 // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
4641 // check is required in this first loop unless we have a nonempty display value (either
4642 // inline or about-to-be-restored)
4643 if ( display === "none" ) {
4644 values[ index ] = dataPriv.get( elem, "display" ) || null;
4645 if ( !values[ index ] ) {
4646 elem.style.display = "";
4647 }
4648 }
4649 if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
4650 values[ index ] = getDefaultDisplay( elem );
4651 }
4652 } else {
4653 if ( display !== "none" ) {
4654 values[ index ] = "none";
4655
4656 // Remember what we're overwriting
4657 dataPriv.set( elem, "display", display );
4658 }
4659 }
4660 }
4661
4662 // Set the display of the elements in a second loop to avoid constant reflow
4663 for ( index = 0; index < length; index++ ) {
4664 if ( values[ index ] != null ) {
4665 elements[ index ].style.display = values[ index ];
4666 }
4667 }
4668
4669 return elements;
4670}
4671
4672jQuery.fn.extend( {
4673 show: function() {
4674 return showHide( this, true );
4675 },
4676 hide: function() {
4677 return showHide( this );
4678 },
4679 toggle: function( state ) {
4680 if ( typeof state === "boolean" ) {
4681 return state ? this.show() : this.hide();
4682 }
4683
4684 return this.each( function() {
4685 if ( isHiddenWithinTree( this ) ) {
4686 jQuery( this ).show();
4687 } else {
4688 jQuery( this ).hide();
4689 }
4690 } );
4691 }
4692} );
4693var rcheckableType = ( /^(?:checkbox|radio)$/i );
4694
4695var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );
4696
4697var rscriptType = ( /^$|\/(?:java|ecma)script/i );
4698
4699
4700
4701// We have to close these tags to support XHTML (#13200)
4702var wrapMap = {
4703
4704 // Support: IE <=9 only
4705 option: [ 1, "<select multiple='multiple'>", "</select>" ],
4706
4707 // XHTML parsers do not magically insert elements in the
4708 // same way that tag soup parsers do. So we cannot shorten
4709 // this by omitting <tbody> or other required elements.
4710 thead: [ 1, "<table>", "</table>" ],
4711 col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
4712 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4713 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4714
4715 _default: [ 0, "", "" ]
4716};
4717
4718// Support: IE <=9 only
4719wrapMap.optgroup = wrapMap.option;
4720
4721wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4722wrapMap.th = wrapMap.td;
4723
4724
4725function getAll( context, tag ) {
4726
4727 // Support: IE <=9 - 11 only
4728 // Use typeof to avoid zero-argument method invocation on host objects (#15151)
4729 var ret;
4730
4731 if ( typeof context.getElementsByTagName !== "undefined" ) {
4732 ret = context.getElementsByTagName( tag || "*" );
4733
4734 } else if ( typeof context.querySelectorAll !== "undefined" ) {
4735 ret = context.querySelectorAll( tag || "*" );
4736
4737 } else {
4738 ret = [];
4739 }
4740
4741 if ( tag === undefined || tag && nodeName( context, tag ) ) {
4742 return jQuery.merge( [ context ], ret );
4743 }
4744
4745 return ret;
4746}
4747
4748
4749// Mark scripts as having already been evaluated
4750function setGlobalEval( elems, refElements ) {
4751 var i = 0,
4752 l = elems.length;
4753
4754 for ( ; i < l; i++ ) {
4755 dataPriv.set(
4756 elems[ i ],
4757 "globalEval",
4758 !refElements || dataPriv.get( refElements[ i ], "globalEval" )
4759 );
4760 }
4761}
4762
4763
4764var rhtml = /<|&#?\w+;/;
4765
4766function buildFragment( elems, context, scripts, selection, ignored ) {
4767 var elem, tmp, tag, wrap, contains, j,
4768 fragment = context.createDocumentFragment(),
4769 nodes = [],
4770 i = 0,
4771 l = elems.length;
4772
4773 for ( ; i < l; i++ ) {
4774 elem = elems[ i ];
4775
4776 if ( elem || elem === 0 ) {
4777
4778 // Add nodes directly
4779 if ( jQuery.type( elem ) === "object" ) {
4780
4781 // Support: Android <=4.0 only, PhantomJS 1 only
4782 // push.apply(_, arraylike) throws on ancient WebKit
4783 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
4784
4785 // Convert non-html into a text node
4786 } else if ( !rhtml.test( elem ) ) {
4787 nodes.push( context.createTextNode( elem ) );
4788
4789 // Convert html into DOM nodes
4790 } else {
4791 tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
4792
4793 // Deserialize a standard representation
4794 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
4795 wrap = wrapMap[ tag ] || wrapMap._default;
4796 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
4797
4798 // Descend through wrappers to the right content
4799 j = wrap[ 0 ];
4800 while ( j-- ) {
4801 tmp = tmp.lastChild;
4802 }
4803
4804 // Support: Android <=4.0 only, PhantomJS 1 only
4805 // push.apply(_, arraylike) throws on ancient WebKit
4806 jQuery.merge( nodes, tmp.childNodes );
4807
4808 // Remember the top-level container
4809 tmp = fragment.firstChild;
4810
4811 // Ensure the created nodes are orphaned (#12392)
4812 tmp.textContent = "";
4813 }
4814 }
4815 }
4816
4817 // Remove wrapper from fragment
4818 fragment.textContent = "";
4819
4820 i = 0;
4821 while ( ( elem = nodes[ i++ ] ) ) {
4822
4823 // Skip elements already in the context collection (trac-4087)
4824 if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
4825 if ( ignored ) {
4826 ignored.push( elem );
4827 }
4828 continue;
4829 }
4830
4831 contains = jQuery.contains( elem.ownerDocument, elem );
4832
4833 // Append to fragment
4834 tmp = getAll( fragment.appendChild( elem ), "script" );
4835
4836 // Preserve script evaluation history
4837 if ( contains ) {
4838 setGlobalEval( tmp );
4839 }
4840
4841 // Capture executables
4842 if ( scripts ) {
4843 j = 0;
4844 while ( ( elem = tmp[ j++ ] ) ) {
4845 if ( rscriptType.test( elem.type || "" ) ) {
4846 scripts.push( elem );
4847 }
4848 }
4849 }
4850 }
4851
4852 return fragment;
4853}
4854
4855
4856( function() {
4857 var fragment = document.createDocumentFragment(),
4858 div = fragment.appendChild( document.createElement( "div" ) ),
4859 input = document.createElement( "input" );
4860
4861 // Support: Android 4.0 - 4.3 only
4862 // Check state lost if the name is set (#11217)
4863 // Support: Windows Web Apps (WWA)
4864 // `name` and `type` must use .setAttribute for WWA (#14901)
4865 input.setAttribute( "type", "radio" );
4866 input.setAttribute( "checked", "checked" );
4867 input.setAttribute( "name", "t" );
4868
4869 div.appendChild( input );
4870
4871 // Support: Android <=4.1 only
4872 // Older WebKit doesn't clone checked state correctly in fragments
4873 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4874
4875 // Support: IE <=11 only
4876 // Make sure textarea (and checkbox) defaultValue is properly cloned
4877 div.innerHTML = "<textarea>x</textarea>";
4878 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4879} )();
4880var documentElement = document.documentElement;
4881
4882
4883
4884var
4885 rkeyEvent = /^key/,
4886 rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
4887 rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
4888
4889function returnTrue() {
4890 return true;
4891}
4892
4893function returnFalse() {
4894 return false;
4895}
4896
4897// Support: IE <=9 only
4898// See #13393 for more info
4899function safeActiveElement() {
4900 try {
4901 return document.activeElement;
4902 } catch ( err ) { }
4903}
4904
4905function on( elem, types, selector, data, fn, one ) {
4906 var origFn, type;
4907
4908 // Types can be a map of types/handlers
4909 if ( typeof types === "object" ) {
4910
4911 // ( types-Object, selector, data )
4912 if ( typeof selector !== "string" ) {
4913
4914 // ( types-Object, data )
4915 data = data || selector;
4916 selector = undefined;
4917 }
4918 for ( type in types ) {
4919 on( elem, type, selector, data, types[ type ], one );
4920 }
4921 return elem;
4922 }
4923
4924 if ( data == null && fn == null ) {
4925
4926 // ( types, fn )
4927 fn = selector;
4928 data = selector = undefined;
4929 } else if ( fn == null ) {
4930 if ( typeof selector === "string" ) {
4931
4932 // ( types, selector, fn )
4933 fn = data;
4934 data = undefined;
4935 } else {
4936
4937 // ( types, data, fn )
4938 fn = data;
4939 data = selector;
4940 selector = undefined;
4941 }
4942 }
4943 if ( fn === false ) {
4944 fn = returnFalse;
4945 } else if ( !fn ) {
4946 return elem;
4947 }
4948
4949 if ( one === 1 ) {
4950 origFn = fn;
4951 fn = function( event ) {
4952
4953 // Can use an empty set, since event contains the info
4954 jQuery().off( event );
4955 return origFn.apply( this, arguments );
4956 };
4957
4958 // Use same guid so caller can remove using origFn
4959 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
4960 }
4961 return elem.each( function() {
4962 jQuery.event.add( this, types, fn, data, selector );
4963 } );
4964}
4965
4966/*
4967 * Helper functions for managing events -- not part of the public interface.
4968 * Props to Dean Edwards' addEvent library for many of the ideas.
4969 */
4970jQuery.event = {
4971
4972 global: {},
4973
4974 add: function( elem, types, handler, data, selector ) {
4975
4976 var handleObjIn, eventHandle, tmp,
4977 events, t, handleObj,
4978 special, handlers, type, namespaces, origType,
4979 elemData = dataPriv.get( elem );
4980
4981 // Don't attach events to noData or text/comment nodes (but allow plain objects)
4982 if ( !elemData ) {
4983 return;
4984 }
4985
4986 // Caller can pass in an object of custom data in lieu of the handler
4987 if ( handler.handler ) {
4988 handleObjIn = handler;
4989 handler = handleObjIn.handler;
4990 selector = handleObjIn.selector;
4991 }
4992
4993 // Ensure that invalid selectors throw exceptions at attach time
4994 // Evaluate against documentElement in case elem is a non-element node (e.g., document)
4995 if ( selector ) {
4996 jQuery.find.matchesSelector( documentElement, selector );
4997 }
4998
4999 // Make sure that the handler has a unique ID, used to find/remove it later
5000 if ( !handler.guid ) {
5001 handler.guid = jQuery.guid++;
5002 }
5003
5004 // Init the element's event structure and main handler, if this is the first
5005 if ( !( events = elemData.events ) ) {
5006 events = elemData.events = {};
5007 }
5008 if ( !( eventHandle = elemData.handle ) ) {
5009 eventHandle = elemData.handle = function( e ) {
5010
5011 // Discard the second event of a jQuery.event.trigger() and
5012 // when an event is called after a page has unloaded
5013 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
5014 jQuery.event.dispatch.apply( elem, arguments ) : undefined;
5015 };
5016 }
5017
5018 // Handle multiple events separated by a space
5019 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5020 t = types.length;
5021 while ( t-- ) {
5022 tmp = rtypenamespace.exec( types[ t ] ) || [];
5023 type = origType = tmp[ 1 ];
5024 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5025
5026 // There *must* be a type, no attaching namespace-only handlers
5027 if ( !type ) {
5028 continue;
5029 }
5030
5031 // If event changes its type, use the special event handlers for the changed type
5032 special = jQuery.event.special[ type ] || {};
5033
5034 // If selector defined, determine special event api type, otherwise given type
5035 type = ( selector ? special.delegateType : special.bindType ) || type;
5036
5037 // Update special based on newly reset type
5038 special = jQuery.event.special[ type ] || {};
5039
5040 // handleObj is passed to all event handlers
5041 handleObj = jQuery.extend( {
5042 type: type,
5043 origType: origType,
5044 data: data,
5045 handler: handler,
5046 guid: handler.guid,
5047 selector: selector,
5048 needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
5049 namespace: namespaces.join( "." )
5050 }, handleObjIn );
5051
5052 // Init the event handler queue if we're the first
5053 if ( !( handlers = events[ type ] ) ) {
5054 handlers = events[ type ] = [];
5055 handlers.delegateCount = 0;
5056
5057 // Only use addEventListener if the special events handler returns false
5058 if ( !special.setup ||
5059 special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
5060
5061 if ( elem.addEventListener ) {
5062 elem.addEventListener( type, eventHandle );
5063 }
5064 }
5065 }
5066
5067 if ( special.add ) {
5068 special.add.call( elem, handleObj );
5069
5070 if ( !handleObj.handler.guid ) {
5071 handleObj.handler.guid = handler.guid;
5072 }
5073 }
5074
5075 // Add to the element's handler list, delegates in front
5076 if ( selector ) {
5077 handlers.splice( handlers.delegateCount++, 0, handleObj );
5078 } else {
5079 handlers.push( handleObj );
5080 }
5081
5082 // Keep track of which events have ever been used, for event optimization
5083 jQuery.event.global[ type ] = true;
5084 }
5085
5086 },
5087
5088 // Detach an event or set of events from an element
5089 remove: function( elem, types, handler, selector, mappedTypes ) {
5090
5091 var j, origCount, tmp,
5092 events, t, handleObj,
5093 special, handlers, type, namespaces, origType,
5094 elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
5095
5096 if ( !elemData || !( events = elemData.events ) ) {
5097 return;
5098 }
5099
5100 // Once for each type.namespace in types; type may be omitted
5101 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5102 t = types.length;
5103 while ( t-- ) {
5104 tmp = rtypenamespace.exec( types[ t ] ) || [];
5105 type = origType = tmp[ 1 ];
5106 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5107
5108 // Unbind all events (on this namespace, if provided) for the element
5109 if ( !type ) {
5110 for ( type in events ) {
5111 jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
5112 }
5113 continue;
5114 }
5115
5116 special = jQuery.event.special[ type ] || {};
5117 type = ( selector ? special.delegateType : special.bindType ) || type;
5118 handlers = events[ type ] || [];
5119 tmp = tmp[ 2 ] &&
5120 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
5121
5122 // Remove matching events
5123 origCount = j = handlers.length;
5124 while ( j-- ) {
5125 handleObj = handlers[ j ];
5126
5127 if ( ( mappedTypes || origType === handleObj.origType ) &&
5128 ( !handler || handler.guid === handleObj.guid ) &&
5129 ( !tmp || tmp.test( handleObj.namespace ) ) &&
5130 ( !selector || selector === handleObj.selector ||
5131 selector === "**" && handleObj.selector ) ) {
5132 handlers.splice( j, 1 );
5133
5134 if ( handleObj.selector ) {
5135 handlers.delegateCount--;
5136 }
5137 if ( special.remove ) {
5138 special.remove.call( elem, handleObj );
5139 }
5140 }
5141 }
5142
5143 // Remove generic event handler if we removed something and no more handlers exist
5144 // (avoids potential for endless recursion during removal of special event handlers)
5145 if ( origCount && !handlers.length ) {
5146 if ( !special.teardown ||
5147 special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
5148
5149 jQuery.removeEvent( elem, type, elemData.handle );
5150 }
5151
5152 delete events[ type ];
5153 }
5154 }
5155
5156 // Remove data and the expando if it's no longer used
5157 if ( jQuery.isEmptyObject( events ) ) {
5158 dataPriv.remove( elem, "handle events" );
5159 }
5160 },
5161
5162 dispatch: function( nativeEvent ) {
5163
5164 // Make a writable jQuery.Event from the native event object
5165 var event = jQuery.event.fix( nativeEvent );
5166
5167 var i, j, ret, matched, handleObj, handlerQueue,
5168 args = new Array( arguments.length ),
5169 handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
5170 special = jQuery.event.special[ event.type ] || {};
5171
5172 // Use the fix-ed jQuery.Event rather than the (read-only) native event
5173 args[ 0 ] = event;
5174
5175 for ( i = 1; i < arguments.length; i++ ) {
5176 args[ i ] = arguments[ i ];
5177 }
5178
5179 event.delegateTarget = this;
5180
5181 // Call the preDispatch hook for the mapped type, and let it bail if desired
5182 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
5183 return;
5184 }
5185
5186 // Determine handlers
5187 handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5188
5189 // Run delegates first; they may want to stop propagation beneath us
5190 i = 0;
5191 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
5192 event.currentTarget = matched.elem;
5193
5194 j = 0;
5195 while ( ( handleObj = matched.handlers[ j++ ] ) &&
5196 !event.isImmediatePropagationStopped() ) {
5197
5198 // Triggered event must either 1) have no namespace, or 2) have namespace(s)
5199 // a subset or equal to those in the bound event (both can have no namespace).
5200 if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
5201
5202 event.handleObj = handleObj;
5203 event.data = handleObj.data;
5204
5205 ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
5206 handleObj.handler ).apply( matched.elem, args );
5207
5208 if ( ret !== undefined ) {
5209 if ( ( event.result = ret ) === false ) {
5210 event.preventDefault();
5211 event.stopPropagation();
5212 }
5213 }
5214 }
5215 }
5216 }
5217
5218 // Call the postDispatch hook for the mapped type
5219 if ( special.postDispatch ) {
5220 special.postDispatch.call( this, event );
5221 }
5222
5223 return event.result;
5224 },
5225
5226 handlers: function( event, handlers ) {
5227 var i, handleObj, sel, matchedHandlers, matchedSelectors,
5228 handlerQueue = [],
5229 delegateCount = handlers.delegateCount,
5230 cur = event.target;
5231
5232 // Find delegate handlers
5233 if ( delegateCount &&
5234
5235 // Support: IE <=9
5236 // Black-hole SVG <use> instance trees (trac-13180)
5237 cur.nodeType &&
5238
5239 // Support: Firefox <=42
5240 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
5241 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
5242 // Support: IE 11 only
5243 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
5244 !( event.type === "click" && event.button >= 1 ) ) {
5245
5246 for ( ; cur !== this; cur = cur.parentNode || this ) {
5247
5248 // Don't check non-elements (#13208)
5249 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
5250 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
5251 matchedHandlers = [];
5252 matchedSelectors = {};
5253 for ( i = 0; i < delegateCount; i++ ) {
5254 handleObj = handlers[ i ];
5255
5256 // Don't conflict with Object.prototype properties (#13203)
5257 sel = handleObj.selector + " ";
5258
5259 if ( matchedSelectors[ sel ] === undefined ) {
5260 matchedSelectors[ sel ] = handleObj.needsContext ?
5261 jQuery( sel, this ).index( cur ) > -1 :
5262 jQuery.find( sel, this, null, [ cur ] ).length;
5263 }
5264 if ( matchedSelectors[ sel ] ) {
5265 matchedHandlers.push( handleObj );
5266 }
5267 }
5268 if ( matchedHandlers.length ) {
5269 handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
5270 }
5271 }
5272 }
5273 }
5274
5275 // Add the remaining (directly-bound) handlers
5276 cur = this;
5277 if ( delegateCount < handlers.length ) {
5278 handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
5279 }
5280
5281 return handlerQueue;
5282 },
5283
5284 addProp: function( name, hook ) {
5285 Object.defineProperty( jQuery.Event.prototype, name, {
5286 enumerable: true,
5287 configurable: true,
5288
5289 get: jQuery.isFunction( hook ) ?
5290 function() {
5291 if ( this.originalEvent ) {
5292 return hook( this.originalEvent );
5293 }
5294 } :
5295 function() {
5296 if ( this.originalEvent ) {
5297 return this.originalEvent[ name ];
5298 }
5299 },
5300
5301 set: function( value ) {
5302 Object.defineProperty( this, name, {
5303 enumerable: true,
5304 configurable: true,
5305 writable: true,
5306 value: value
5307 } );
5308 }
5309 } );
5310 },
5311
5312 fix: function( originalEvent ) {
5313 return originalEvent[ jQuery.expando ] ?
5314 originalEvent :
5315 new jQuery.Event( originalEvent );
5316 },
5317
5318 special: {
5319 load: {
5320
5321 // Prevent triggered image.load events from bubbling to window.load
5322 noBubble: true
5323 },
5324 focus: {
5325
5326 // Fire native event if possible so blur/focus sequence is correct
5327 trigger: function() {
5328 if ( this !== safeActiveElement() && this.focus ) {
5329 this.focus();
5330 return false;
5331 }
5332 },
5333 delegateType: "focusin"
5334 },
5335 blur: {
5336 trigger: function() {
5337 if ( this === safeActiveElement() && this.blur ) {
5338 this.blur();
5339 return false;
5340 }
5341 },
5342 delegateType: "focusout"
5343 },
5344 click: {
5345
5346 // For checkbox, fire native event so checked state will be right
5347 trigger: function() {
5348 if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
5349 this.click();
5350 return false;
5351 }
5352 },
5353
5354 // For cross-browser consistency, don't fire native .click() on links
5355 _default: function( event ) {
5356 return nodeName( event.target, "a" );
5357 }
5358 },
5359
5360 beforeunload: {
5361 postDispatch: function( event ) {
5362
5363 // Support: Firefox 20+
5364 // Firefox doesn't alert if the returnValue field is not set.
5365 if ( event.result !== undefined && event.originalEvent ) {
5366 event.originalEvent.returnValue = event.result;
5367 }
5368 }
5369 }
5370 }
5371};
5372
5373jQuery.removeEvent = function( elem, type, handle ) {
5374
5375 // This "if" is needed for plain objects
5376 if ( elem.removeEventListener ) {
5377 elem.removeEventListener( type, handle );
5378 }
5379};
5380
5381jQuery.Event = function( src, props ) {
5382
5383 // Allow instantiation without the 'new' keyword
5384 if ( !( this instanceof jQuery.Event ) ) {
5385 return new jQuery.Event( src, props );
5386 }
5387
5388 // Event object
5389 if ( src && src.type ) {
5390 this.originalEvent = src;
5391 this.type = src.type;
5392
5393 // Events bubbling up the document may have been marked as prevented
5394 // by a handler lower down the tree; reflect the correct value.
5395 this.isDefaultPrevented = src.defaultPrevented ||
5396 src.defaultPrevented === undefined &&
5397
5398 // Support: Android <=2.3 only
5399 src.returnValue === false ?
5400 returnTrue :
5401 returnFalse;
5402
5403 // Create target properties
5404 // Support: Safari <=6 - 7 only
5405 // Target should not be a text node (#504, #13143)
5406 this.target = ( src.target && src.target.nodeType === 3 ) ?
5407 src.target.parentNode :
5408 src.target;
5409
5410 this.currentTarget = src.currentTarget;
5411 this.relatedTarget = src.relatedTarget;
5412
5413 // Event type
5414 } else {
5415 this.type = src;
5416 }
5417
5418 // Put explicitly provided properties onto the event object
5419 if ( props ) {
5420 jQuery.extend( this, props );
5421 }
5422
5423 // Create a timestamp if incoming event doesn't have one
5424 this.timeStamp = src && src.timeStamp || jQuery.now();
5425
5426 // Mark it as fixed
5427 this[ jQuery.expando ] = true;
5428};
5429
5430// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5431// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5432jQuery.Event.prototype = {
5433 constructor: jQuery.Event,
5434 isDefaultPrevented: returnFalse,
5435 isPropagationStopped: returnFalse,
5436 isImmediatePropagationStopped: returnFalse,
5437 isSimulated: false,
5438
5439 preventDefault: function() {
5440 var e = this.originalEvent;
5441
5442 this.isDefaultPrevented = returnTrue;
5443
5444 if ( e && !this.isSimulated ) {
5445 e.preventDefault();
5446 }
5447 },
5448 stopPropagation: function() {
5449 var e = this.originalEvent;
5450
5451 this.isPropagationStopped = returnTrue;
5452
5453 if ( e && !this.isSimulated ) {
5454 e.stopPropagation();
5455 }
5456 },
5457 stopImmediatePropagation: function() {
5458 var e = this.originalEvent;
5459
5460 this.isImmediatePropagationStopped = returnTrue;
5461
5462 if ( e && !this.isSimulated ) {
5463 e.stopImmediatePropagation();
5464 }
5465
5466 this.stopPropagation();
5467 }
5468};
5469
5470// Includes all common event props including KeyEvent and MouseEvent specific props
5471jQuery.each( {
5472 altKey: true,
5473 bubbles: true,
5474 cancelable: true,
5475 changedTouches: true,
5476 ctrlKey: true,
5477 detail: true,
5478 eventPhase: true,
5479 metaKey: true,
5480 pageX: true,
5481 pageY: true,
5482 shiftKey: true,
5483 view: true,
5484 "char": true,
5485 charCode: true,
5486 key: true,
5487 keyCode: true,
5488 button: true,
5489 buttons: true,
5490 clientX: true,
5491 clientY: true,
5492 offsetX: true,
5493 offsetY: true,
5494 pointerId: true,
5495 pointerType: true,
5496 screenX: true,
5497 screenY: true,
5498 targetTouches: true,
5499 toElement: true,
5500 touches: true,
5501
5502 which: function( event ) {
5503 var button = event.button;
5504
5505 // Add which for key events
5506 if ( event.which == null && rkeyEvent.test( event.type ) ) {
5507 return event.charCode != null ? event.charCode : event.keyCode;
5508 }
5509
5510 // Add which for click: 1 === left; 2 === middle; 3 === right
5511 if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
5512 if ( button & 1 ) {
5513 return 1;
5514 }
5515
5516 if ( button & 2 ) {
5517 return 3;
5518 }
5519
5520 if ( button & 4 ) {
5521 return 2;
5522 }
5523
5524 return 0;
5525 }
5526
5527 return event.which;
5528 }
5529}, jQuery.event.addProp );
5530
5531// Create mouseenter/leave events using mouseover/out and event-time checks
5532// so that event delegation works in jQuery.
5533// Do the same for pointerenter/pointerleave and pointerover/pointerout
5534//
5535// Support: Safari 7 only
5536// Safari sends mouseenter too often; see:
5537// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5538// for the description of the bug (it existed in older Chrome versions as well).
5539jQuery.each( {
5540 mouseenter: "mouseover",
5541 mouseleave: "mouseout",
5542 pointerenter: "pointerover",
5543 pointerleave: "pointerout"
5544}, function( orig, fix ) {
5545 jQuery.event.special[ orig ] = {
5546 delegateType: fix,
5547 bindType: fix,
5548
5549 handle: function( event ) {
5550 var ret,
5551 target = this,
5552 related = event.relatedTarget,
5553 handleObj = event.handleObj;
5554
5555 // For mouseenter/leave call the handler if related is outside the target.
5556 // NB: No relatedTarget if the mouse left/entered the browser window
5557 if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5558 event.type = handleObj.origType;
5559 ret = handleObj.handler.apply( this, arguments );
5560 event.type = fix;
5561 }
5562 return ret;
5563 }
5564 };
5565} );
5566
5567jQuery.fn.extend( {
5568
5569 on: function( types, selector, data, fn ) {
5570 return on( this, types, selector, data, fn );
5571 },
5572 one: function( types, selector, data, fn ) {
5573 return on( this, types, selector, data, fn, 1 );
5574 },
5575 off: function( types, selector, fn ) {
5576 var handleObj, type;
5577 if ( types && types.preventDefault && types.handleObj ) {
5578
5579 // ( event ) dispatched jQuery.Event
5580 handleObj = types.handleObj;
5581 jQuery( types.delegateTarget ).off(
5582 handleObj.namespace ?
5583 handleObj.origType + "." + handleObj.namespace :
5584 handleObj.origType,
5585 handleObj.selector,
5586 handleObj.handler
5587 );
5588 return this;
5589 }
5590 if ( typeof types === "object" ) {
5591
5592 // ( types-object [, selector] )
5593 for ( type in types ) {
5594 this.off( type, selector, types[ type ] );
5595 }
5596 return this;
5597 }
5598 if ( selector === false || typeof selector === "function" ) {
5599
5600 // ( types [, fn] )
5601 fn = selector;
5602 selector = undefined;
5603 }
5604 if ( fn === false ) {
5605 fn = returnFalse;
5606 }
5607 return this.each( function() {
5608 jQuery.event.remove( this, types, fn, selector );
5609 } );
5610 }
5611} );
5612
5613
5614var
5615
5616 /* eslint-disable max-len */
5617
5618 // See https://github.com/eslint/eslint/issues/3229
5619 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
5620
5621 /* eslint-enable */
5622
5623 // Support: IE <=10 - 11, Edge 12 - 13
5624 // In IE/Edge using regex groups here causes severe slowdowns.
5625 // See https://connect.microsoft.com/IE/feedback/details/1736512/
5626 rnoInnerhtml = /<script|<style|<link/i,
5627
5628 // checked="checked" or checked
5629 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5630 rscriptTypeMasked = /^true\/(.*)/,
5631 rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
5632
5633// Prefer a tbody over its parent table for containing new rows
5634function manipulationTarget( elem, content ) {
5635 if ( nodeName( elem, "table" ) &&
5636 nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
5637
5638 return jQuery( ">tbody", elem )[ 0 ] || elem;
5639 }
5640
5641 return elem;
5642}
5643
5644// Replace/restore the type attribute of script elements for safe DOM manipulation
5645function disableScript( elem ) {
5646 elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
5647 return elem;
5648}
5649function restoreScript( elem ) {
5650 var match = rscriptTypeMasked.exec( elem.type );
5651
5652 if ( match ) {
5653 elem.type = match[ 1 ];
5654 } else {
5655 elem.removeAttribute( "type" );
5656 }
5657
5658 return elem;
5659}
5660
5661function cloneCopyEvent( src, dest ) {
5662 var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
5663
5664 if ( dest.nodeType !== 1 ) {
5665 return;
5666 }
5667
5668 // 1. Copy private data: events, handlers, etc.
5669 if ( dataPriv.hasData( src ) ) {
5670 pdataOld = dataPriv.access( src );
5671 pdataCur = dataPriv.set( dest, pdataOld );
5672 events = pdataOld.events;
5673
5674 if ( events ) {
5675 delete pdataCur.handle;
5676 pdataCur.events = {};
5677
5678 for ( type in events ) {
5679 for ( i = 0, l = events[ type ].length; i < l; i++ ) {
5680 jQuery.event.add( dest, type, events[ type ][ i ] );
5681 }
5682 }
5683 }
5684 }
5685
5686 // 2. Copy user data
5687 if ( dataUser.hasData( src ) ) {
5688 udataOld = dataUser.access( src );
5689 udataCur = jQuery.extend( {}, udataOld );
5690
5691 dataUser.set( dest, udataCur );
5692 }
5693}
5694
5695// Fix IE bugs, see support tests
5696function fixInput( src, dest ) {
5697 var nodeName = dest.nodeName.toLowerCase();
5698
5699 // Fails to persist the checked state of a cloned checkbox or radio button.
5700 if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
5701 dest.checked = src.checked;
5702
5703 // Fails to return the selected option to the default selected state when cloning options
5704 } else if ( nodeName === "input" || nodeName === "textarea" ) {
5705 dest.defaultValue = src.defaultValue;
5706 }
5707}
5708
5709
5710function domManip( collection, args, callback, ignored ) {
5711
5712 // Flatten any nested arrays
5713 args = concat.apply( [], args );
5714
5715 var fragment, first, scripts, hasScripts, node, doc,
5716 i = 0,
5717 l = collection.length,
5718 iNoClone = l - 1,
5719 value = args[ 0 ],
5720 isFunction = jQuery.isFunction( value );
5721
5722 // We can't cloneNode fragments that contain checked, in WebKit
5723 if ( isFunction ||
5724 ( l > 1 && typeof value === "string" &&
5725 !support.checkClone && rchecked.test( value ) ) ) {
5726 return collection.each( function( index ) {
5727 var self = collection.eq( index );
5728 if ( isFunction ) {
5729 args[ 0 ] = value.call( this, index, self.html() );
5730 }
5731 domManip( self, args, callback, ignored );
5732 } );
5733 }
5734
5735 if ( l ) {
5736 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
5737 first = fragment.firstChild;
5738
5739 if ( fragment.childNodes.length === 1 ) {
5740 fragment = first;
5741 }
5742
5743 // Require either new content or an interest in ignored elements to invoke the callback
5744 if ( first || ignored ) {
5745 scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
5746 hasScripts = scripts.length;
5747
5748 // Use the original fragment for the last item
5749 // instead of the first because it can end up
5750 // being emptied incorrectly in certain situations (#8070).
5751 for ( ; i < l; i++ ) {
5752 node = fragment;
5753
5754 if ( i !== iNoClone ) {
5755 node = jQuery.clone( node, true, true );
5756
5757 // Keep references to cloned scripts for later restoration
5758 if ( hasScripts ) {
5759
5760 // Support: Android <=4.0 only, PhantomJS 1 only
5761 // push.apply(_, arraylike) throws on ancient WebKit
5762 jQuery.merge( scripts, getAll( node, "script" ) );
5763 }
5764 }
5765
5766 callback.call( collection[ i ], node, i );
5767 }
5768
5769 if ( hasScripts ) {
5770 doc = scripts[ scripts.length - 1 ].ownerDocument;
5771
5772 // Reenable scripts
5773 jQuery.map( scripts, restoreScript );
5774
5775 // Evaluate executable scripts on first document insertion
5776 for ( i = 0; i < hasScripts; i++ ) {
5777 node = scripts[ i ];
5778 if ( rscriptType.test( node.type || "" ) &&
5779 !dataPriv.access( node, "globalEval" ) &&
5780 jQuery.contains( doc, node ) ) {
5781
5782 if ( node.src ) {
5783
5784 // Optional AJAX dependency, but won't run scripts if not present
5785 if ( jQuery._evalUrl ) {
5786 jQuery._evalUrl( node.src );
5787 }
5788 } else {
5789 DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
5790 }
5791 }
5792 }
5793 }
5794 }
5795 }
5796
5797 return collection;
5798}
5799
5800function remove( elem, selector, keepData ) {
5801 var node,
5802 nodes = selector ? jQuery.filter( selector, elem ) : elem,
5803 i = 0;
5804
5805 for ( ; ( node = nodes[ i ] ) != null; i++ ) {
5806 if ( !keepData && node.nodeType === 1 ) {
5807 jQuery.cleanData( getAll( node ) );
5808 }
5809
5810 if ( node.parentNode ) {
5811 if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
5812 setGlobalEval( getAll( node, "script" ) );
5813 }
5814 node.parentNode.removeChild( node );
5815 }
5816 }
5817
5818 return elem;
5819}
5820
5821jQuery.extend( {
5822 htmlPrefilter: function( html ) {
5823 return html.replace( rxhtmlTag, "<$1></$2>" );
5824 },
5825
5826 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5827 var i, l, srcElements, destElements,
5828 clone = elem.cloneNode( true ),
5829 inPage = jQuery.contains( elem.ownerDocument, elem );
5830
5831 // Fix IE cloning issues
5832 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
5833 !jQuery.isXMLDoc( elem ) ) {
5834
5835 // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
5836 destElements = getAll( clone );
5837 srcElements = getAll( elem );
5838
5839 for ( i = 0, l = srcElements.length; i < l; i++ ) {
5840 fixInput( srcElements[ i ], destElements[ i ] );
5841 }
5842 }
5843
5844 // Copy the events from the original to the clone
5845 if ( dataAndEvents ) {
5846 if ( deepDataAndEvents ) {
5847 srcElements = srcElements || getAll( elem );
5848 destElements = destElements || getAll( clone );
5849
5850 for ( i = 0, l = srcElements.length; i < l; i++ ) {
5851 cloneCopyEvent( srcElements[ i ], destElements[ i ] );
5852 }
5853 } else {
5854 cloneCopyEvent( elem, clone );
5855 }
5856 }
5857
5858 // Preserve script evaluation history
5859 destElements = getAll( clone, "script" );
5860 if ( destElements.length > 0 ) {
5861 setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
5862 }
5863
5864 // Return the cloned set
5865 return clone;
5866 },
5867
5868 cleanData: function( elems ) {
5869 var data, elem, type,
5870 special = jQuery.event.special,
5871 i = 0;
5872
5873 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
5874 if ( acceptData( elem ) ) {
5875 if ( ( data = elem[ dataPriv.expando ] ) ) {
5876 if ( data.events ) {
5877 for ( type in data.events ) {
5878 if ( special[ type ] ) {
5879 jQuery.event.remove( elem, type );
5880
5881 // This is a shortcut to avoid jQuery.event.remove's overhead
5882 } else {
5883 jQuery.removeEvent( elem, type, data.handle );
5884 }
5885 }
5886 }
5887
5888 // Support: Chrome <=35 - 45+
5889 // Assign undefined instead of using delete, see Data#remove
5890 elem[ dataPriv.expando ] = undefined;
5891 }
5892 if ( elem[ dataUser.expando ] ) {
5893
5894 // Support: Chrome <=35 - 45+
5895 // Assign undefined instead of using delete, see Data#remove
5896 elem[ dataUser.expando ] = undefined;
5897 }
5898 }
5899 }
5900 }
5901} );
5902
5903jQuery.fn.extend( {
5904 detach: function( selector ) {
5905 return remove( this, selector, true );
5906 },
5907
5908 remove: function( selector ) {
5909 return remove( this, selector );
5910 },
5911
5912 text: function( value ) {
5913 return access( this, function( value ) {
5914 return value === undefined ?
5915 jQuery.text( this ) :
5916 this.empty().each( function() {
5917 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5918 this.textContent = value;
5919 }
5920 } );
5921 }, null, value, arguments.length );
5922 },
5923
5924 append: function() {
5925 return domManip( this, arguments, function( elem ) {
5926 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5927 var target = manipulationTarget( this, elem );
5928 target.appendChild( elem );
5929 }
5930 } );
5931 },
5932
5933 prepend: function() {
5934 return domManip( this, arguments, function( elem ) {
5935 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5936 var target = manipulationTarget( this, elem );
5937 target.insertBefore( elem, target.firstChild );
5938 }
5939 } );
5940 },
5941
5942 before: function() {
5943 return domManip( this, arguments, function( elem ) {
5944 if ( this.parentNode ) {
5945 this.parentNode.insertBefore( elem, this );
5946 }
5947 } );
5948 },
5949
5950 after: function() {
5951 return domManip( this, arguments, function( elem ) {
5952 if ( this.parentNode ) {
5953 this.parentNode.insertBefore( elem, this.nextSibling );
5954 }
5955 } );
5956 },
5957
5958 empty: function() {
5959 var elem,
5960 i = 0;
5961
5962 for ( ; ( elem = this[ i ] ) != null; i++ ) {
5963 if ( elem.nodeType === 1 ) {
5964
5965 // Prevent memory leaks
5966 jQuery.cleanData( getAll( elem, false ) );
5967
5968 // Remove any remaining nodes
5969 elem.textContent = "";
5970 }
5971 }
5972
5973 return this;
5974 },
5975
5976 clone: function( dataAndEvents, deepDataAndEvents ) {
5977 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5978 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5979
5980 return this.map( function() {
5981 return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5982 } );
5983 },
5984
5985 html: function( value ) {
5986 return access( this, function( value ) {
5987 var elem = this[ 0 ] || {},
5988 i = 0,
5989 l = this.length;
5990
5991 if ( value === undefined && elem.nodeType === 1 ) {
5992 return elem.innerHTML;
5993 }
5994
5995 // See if we can take a shortcut and just use innerHTML
5996 if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
5997 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
5998
5999 value = jQuery.htmlPrefilter( value );
6000
6001 try {
6002 for ( ; i < l; i++ ) {
6003 elem = this[ i ] || {};
6004
6005 // Remove element nodes and prevent memory leaks
6006 if ( elem.nodeType === 1 ) {
6007 jQuery.cleanData( getAll( elem, false ) );
6008 elem.innerHTML = value;
6009 }
6010 }
6011
6012 elem = 0;
6013
6014 // If using innerHTML throws an exception, use the fallback method
6015 } catch ( e ) {}
6016 }
6017
6018 if ( elem ) {
6019 this.empty().append( value );
6020 }
6021 }, null, value, arguments.length );
6022 },
6023
6024 replaceWith: function() {
6025 var ignored = [];
6026
6027 // Make the changes, replacing each non-ignored context element with the new content
6028 return domManip( this, arguments, function( elem ) {
6029 var parent = this.parentNode;
6030
6031 if ( jQuery.inArray( this, ignored ) < 0 ) {
6032 jQuery.cleanData( getAll( this ) );
6033 if ( parent ) {
6034 parent.replaceChild( elem, this );
6035 }
6036 }
6037
6038 // Force callback invocation
6039 }, ignored );
6040 }
6041} );
6042
6043jQuery.each( {
6044 appendTo: "append",
6045 prependTo: "prepend",
6046 insertBefore: "before",
6047 insertAfter: "after",
6048 replaceAll: "replaceWith"
6049}, function( name, original ) {
6050 jQuery.fn[ name ] = function( selector ) {
6051 var elems,
6052 ret = [],
6053 insert = jQuery( selector ),
6054 last = insert.length - 1,
6055 i = 0;
6056
6057 for ( ; i <= last; i++ ) {
6058 elems = i === last ? this : this.clone( true );
6059 jQuery( insert[ i ] )[ original ]( elems );
6060
6061 // Support: Android <=4.0 only, PhantomJS 1 only
6062 // .get() because push.apply(_, arraylike) throws on ancient WebKit
6063 push.apply( ret, elems.get() );
6064 }
6065
6066 return this.pushStack( ret );
6067 };
6068} );
6069var rmargin = ( /^margin/ );
6070
6071var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6072
6073var getStyles = function( elem ) {
6074
6075 // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
6076 // IE throws on elements created in popups
6077 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
6078 var view = elem.ownerDocument.defaultView;
6079
6080 if ( !view || !view.opener ) {
6081 view = window;
6082 }
6083
6084 return view.getComputedStyle( elem );
6085 };
6086
6087
6088
6089( function() {
6090
6091 // Executing both pixelPosition & boxSizingReliable tests require only one layout
6092 // so they're executed at the same time to save the second computation.
6093 function computeStyleTests() {
6094
6095 // This is a singleton, we need to execute it only once
6096 if ( !div ) {
6097 return;
6098 }
6099
6100 div.style.cssText =
6101 "box-sizing:border-box;" +
6102 "position:relative;display:block;" +
6103 "margin:auto;border:1px;padding:1px;" +
6104 "top:1%;width:50%";
6105 div.innerHTML = "";
6106 documentElement.appendChild( container );
6107
6108 var divStyle = window.getComputedStyle( div );
6109 pixelPositionVal = divStyle.top !== "1%";
6110
6111 // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
6112 reliableMarginLeftVal = divStyle.marginLeft === "2px";
6113 boxSizingReliableVal = divStyle.width === "4px";
6114
6115 // Support: Android 4.0 - 4.3 only
6116 // Some styles come back with percentage values, even though they shouldn't
6117 div.style.marginRight = "50%";
6118 pixelMarginRightVal = divStyle.marginRight === "4px";
6119
6120 documentElement.removeChild( container );
6121
6122 // Nullify the div so it wouldn't be stored in the memory and
6123 // it will also be a sign that checks already performed
6124 div = null;
6125 }
6126
6127 var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
6128 container = document.createElement( "div" ),
6129 div = document.createElement( "div" );
6130
6131 // Finish early in limited (non-browser) environments
6132 if ( !div.style ) {
6133 return;
6134 }
6135
6136 // Support: IE <=9 - 11 only
6137 // Style of cloned element affects source element cloned (#8908)
6138 div.style.backgroundClip = "content-box";
6139 div.cloneNode( true ).style.backgroundClip = "";
6140 support.clearCloneStyle = div.style.backgroundClip === "content-box";
6141
6142 container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
6143 "padding:0;margin-top:1px;position:absolute";
6144 container.appendChild( div );
6145
6146 jQuery.extend( support, {
6147 pixelPosition: function() {
6148 computeStyleTests();
6149 return pixelPositionVal;
6150 },
6151 boxSizingReliable: function() {
6152 computeStyleTests();
6153 return boxSizingReliableVal;
6154 },
6155 pixelMarginRight: function() {
6156 computeStyleTests();
6157 return pixelMarginRightVal;
6158 },
6159 reliableMarginLeft: function() {
6160 computeStyleTests();
6161 return reliableMarginLeftVal;
6162 }
6163 } );
6164} )();
6165
6166
6167function curCSS( elem, name, computed ) {
6168 var width, minWidth, maxWidth, ret,
6169
6170 // Support: Firefox 51+
6171 // Retrieving style before computed somehow
6172 // fixes an issue with getting wrong values
6173 // on detached elements
6174 style = elem.style;
6175
6176 computed = computed || getStyles( elem );
6177
6178 // getPropertyValue is needed for:
6179 // .css('filter') (IE 9 only, #12537)
6180 // .css('--customProperty) (#3144)
6181 if ( computed ) {
6182 ret = computed.getPropertyValue( name ) || computed[ name ];
6183
6184 if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
6185 ret = jQuery.style( elem, name );
6186 }
6187
6188 // A tribute to the "awesome hack by Dean Edwards"
6189 // Android Browser returns percentage for some values,
6190 // but width seems to be reliably pixels.
6191 // This is against the CSSOM draft spec:
6192 // https://drafts.csswg.org/cssom/#resolved-values
6193 if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
6194
6195 // Remember the original values
6196 width = style.width;
6197 minWidth = style.minWidth;
6198 maxWidth = style.maxWidth;
6199
6200 // Put in the new values to get a computed value out
6201 style.minWidth = style.maxWidth = style.width = ret;
6202 ret = computed.width;
6203
6204 // Revert the changed values
6205 style.width = width;
6206 style.minWidth = minWidth;
6207 style.maxWidth = maxWidth;
6208 }
6209 }
6210
6211 return ret !== undefined ?
6212
6213 // Support: IE <=9 - 11 only
6214 // IE returns zIndex value as an integer.
6215 ret + "" :
6216 ret;
6217}
6218
6219
6220function addGetHookIf( conditionFn, hookFn ) {
6221
6222 // Define the hook, we'll check on the first run if it's really needed.
6223 return {
6224 get: function() {
6225 if ( conditionFn() ) {
6226
6227 // Hook not needed (or it's not possible to use it due
6228 // to missing dependency), remove it.
6229 delete this.get;
6230 return;
6231 }
6232
6233 // Hook needed; redefine it so that the support test is not executed again.
6234 return ( this.get = hookFn ).apply( this, arguments );
6235 }
6236 };
6237}
6238
6239
6240var
6241
6242 // Swappable if display is none or starts with table
6243 // except "table", "table-cell", or "table-caption"
6244 // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6245 rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6246 rcustomProp = /^--/,
6247 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6248 cssNormalTransform = {
6249 letterSpacing: "0",
6250 fontWeight: "400"
6251 },
6252
6253 cssPrefixes = [ "Webkit", "Moz", "ms" ],
6254 emptyStyle = document.createElement( "div" ).style;
6255
6256// Return a css property mapped to a potentially vendor prefixed property
6257function vendorPropName( name ) {
6258
6259 // Shortcut for names that are not vendor prefixed
6260 if ( name in emptyStyle ) {
6261 return name;
6262 }
6263
6264 // Check for vendor prefixed names
6265 var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
6266 i = cssPrefixes.length;
6267
6268 while ( i-- ) {
6269 name = cssPrefixes[ i ] + capName;
6270 if ( name in emptyStyle ) {
6271 return name;
6272 }
6273 }
6274}
6275
6276// Return a property mapped along what jQuery.cssProps suggests or to
6277// a vendor prefixed property.
6278function finalPropName( name ) {
6279 var ret = jQuery.cssProps[ name ];
6280 if ( !ret ) {
6281 ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
6282 }
6283 return ret;
6284}
6285
6286function setPositiveNumber( elem, value, subtract ) {
6287
6288 // Any relative (+/-) values have already been
6289 // normalized at this point
6290 var matches = rcssNum.exec( value );
6291 return matches ?
6292
6293 // Guard against undefined "subtract", e.g., when used as in cssHooks
6294 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
6295 value;
6296}
6297
6298function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
6299 var i,
6300 val = 0;
6301
6302 // If we already have the right measurement, avoid augmentation
6303 if ( extra === ( isBorderBox ? "border" : "content" ) ) {
6304 i = 4;
6305
6306 // Otherwise initialize for horizontal or vertical properties
6307 } else {
6308 i = name === "width" ? 1 : 0;
6309 }
6310
6311 for ( ; i < 4; i += 2 ) {
6312
6313 // Both box models exclude margin, so add it if we want it
6314 if ( extra === "margin" ) {
6315 val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
6316 }
6317
6318 if ( isBorderBox ) {
6319
6320 // border-box includes padding, so remove it if we want content
6321 if ( extra === "content" ) {
6322 val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6323 }
6324
6325 // At this point, extra isn't border nor margin, so remove border
6326 if ( extra !== "margin" ) {
6327 val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6328 }
6329 } else {
6330
6331 // At this point, extra isn't content, so add padding
6332 val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6333
6334 // At this point, extra isn't content nor padding, so add border
6335 if ( extra !== "padding" ) {
6336 val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6337 }
6338 }
6339 }
6340
6341 return val;
6342}
6343
6344function getWidthOrHeight( elem, name, extra ) {
6345
6346 // Start with computed style
6347 var valueIsBorderBox,
6348 styles = getStyles( elem ),
6349 val = curCSS( elem, name, styles ),
6350 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6351
6352 // Computed unit is not pixels. Stop here and return.
6353 if ( rnumnonpx.test( val ) ) {
6354 return val;
6355 }
6356
6357 // Check for style in case a browser which returns unreliable values
6358 // for getComputedStyle silently falls back to the reliable elem.style
6359 valueIsBorderBox = isBorderBox &&
6360 ( support.boxSizingReliable() || val === elem.style[ name ] );
6361
6362 // Fall back to offsetWidth/Height when value is "auto"
6363 // This happens for inline elements with no explicit setting (gh-3571)
6364 if ( val === "auto" ) {
6365 val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];
6366 }
6367
6368 // Normalize "", auto, and prepare for extra
6369 val = parseFloat( val ) || 0;
6370
6371 // Use the active box-sizing model to add/subtract irrelevant styles
6372 return ( val +
6373 augmentWidthOrHeight(
6374 elem,
6375 name,
6376 extra || ( isBorderBox ? "border" : "content" ),
6377 valueIsBorderBox,
6378 styles
6379 )
6380 ) + "px";
6381}
6382
6383jQuery.extend( {
6384
6385 // Add in style property hooks for overriding the default
6386 // behavior of getting and setting a style property
6387 cssHooks: {
6388 opacity: {
6389 get: function( elem, computed ) {
6390 if ( computed ) {
6391
6392 // We should always get a number back from opacity
6393 var ret = curCSS( elem, "opacity" );
6394 return ret === "" ? "1" : ret;
6395 }
6396 }
6397 }
6398 },
6399
6400 // Don't automatically add "px" to these possibly-unitless properties
6401 cssNumber: {
6402 "animationIterationCount": true,
6403 "columnCount": true,
6404 "fillOpacity": true,
6405 "flexGrow": true,
6406 "flexShrink": true,
6407 "fontWeight": true,
6408 "lineHeight": true,
6409 "opacity": true,
6410 "order": true,
6411 "orphans": true,
6412 "widows": true,
6413 "zIndex": true,
6414 "zoom": true
6415 },
6416
6417 // Add in properties whose names you wish to fix before
6418 // setting or getting the value
6419 cssProps: {
6420 "float": "cssFloat"
6421 },
6422
6423 // Get and set the style property on a DOM Node
6424 style: function( elem, name, value, extra ) {
6425
6426 // Don't set styles on text and comment nodes
6427 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6428 return;
6429 }
6430
6431 // Make sure that we're working with the right name
6432 var ret, type, hooks,
6433 origName = jQuery.camelCase( name ),
6434 isCustomProp = rcustomProp.test( name ),
6435 style = elem.style;
6436
6437 // Make sure that we're working with the right name. We don't
6438 // want to query the value if it is a CSS custom property
6439 // since they are user-defined.
6440 if ( !isCustomProp ) {
6441 name = finalPropName( origName );
6442 }
6443
6444 // Gets hook for the prefixed version, then unprefixed version
6445 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6446
6447 // Check if we're setting a value
6448 if ( value !== undefined ) {
6449 type = typeof value;
6450
6451 // Convert "+=" or "-=" to relative numbers (#7345)
6452 if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
6453 value = adjustCSS( elem, name, ret );
6454
6455 // Fixes bug #9237
6456 type = "number";
6457 }
6458
6459 // Make sure that null and NaN values aren't set (#7116)
6460 if ( value == null || value !== value ) {
6461 return;
6462 }
6463
6464 // If a number was passed in, add the unit (except for certain CSS properties)
6465 if ( type === "number" ) {
6466 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
6467 }
6468
6469 // background-* props affect original clone's values
6470 if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
6471 style[ name ] = "inherit";
6472 }
6473
6474 // If a hook was provided, use that value, otherwise just set the specified value
6475 if ( !hooks || !( "set" in hooks ) ||
6476 ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
6477
6478 if ( isCustomProp ) {
6479 style.setProperty( name, value );
6480 } else {
6481 style[ name ] = value;
6482 }
6483 }
6484
6485 } else {
6486
6487 // If a hook was provided get the non-computed value from there
6488 if ( hooks && "get" in hooks &&
6489 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
6490
6491 return ret;
6492 }
6493
6494 // Otherwise just get the value from the style object
6495 return style[ name ];
6496 }
6497 },
6498
6499 css: function( elem, name, extra, styles ) {
6500 var val, num, hooks,
6501 origName = jQuery.camelCase( name ),
6502 isCustomProp = rcustomProp.test( name );
6503
6504 // Make sure that we're working with the right name. We don't
6505 // want to modify the value if it is a CSS custom property
6506 // since they are user-defined.
6507 if ( !isCustomProp ) {
6508 name = finalPropName( origName );
6509 }
6510
6511 // Try prefixed name followed by the unprefixed name
6512 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6513
6514 // If a hook was provided get the computed value from there
6515 if ( hooks && "get" in hooks ) {
6516 val = hooks.get( elem, true, extra );
6517 }
6518
6519 // Otherwise, if a way to get the computed value exists, use that
6520 if ( val === undefined ) {
6521 val = curCSS( elem, name, styles );
6522 }
6523
6524 // Convert "normal" to computed value
6525 if ( val === "normal" && name in cssNormalTransform ) {
6526 val = cssNormalTransform[ name ];
6527 }
6528
6529 // Make numeric if forced or a qualifier was provided and val looks numeric
6530 if ( extra === "" || extra ) {
6531 num = parseFloat( val );
6532 return extra === true || isFinite( num ) ? num || 0 : val;
6533 }
6534
6535 return val;
6536 }
6537} );
6538
6539jQuery.each( [ "height", "width" ], function( i, name ) {
6540 jQuery.cssHooks[ name ] = {
6541 get: function( elem, computed, extra ) {
6542 if ( computed ) {
6543
6544 // Certain elements can have dimension info if we invisibly show them
6545 // but it must have a current display style that would benefit
6546 return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
6547
6548 // Support: Safari 8+
6549 // Table columns in Safari have non-zero offsetWidth & zero
6550 // getBoundingClientRect().width unless display is changed.
6551 // Support: IE <=11 only
6552 // Running getBoundingClientRect on a disconnected node
6553 // in IE throws an error.
6554 ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
6555 swap( elem, cssShow, function() {
6556 return getWidthOrHeight( elem, name, extra );
6557 } ) :
6558 getWidthOrHeight( elem, name, extra );
6559 }
6560 },
6561
6562 set: function( elem, value, extra ) {
6563 var matches,
6564 styles = extra && getStyles( elem ),
6565 subtract = extra && augmentWidthOrHeight(
6566 elem,
6567 name,
6568 extra,
6569 jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6570 styles
6571 );
6572
6573 // Convert to pixels if value adjustment is needed
6574 if ( subtract && ( matches = rcssNum.exec( value ) ) &&
6575 ( matches[ 3 ] || "px" ) !== "px" ) {
6576
6577 elem.style[ name ] = value;
6578 value = jQuery.css( elem, name );
6579 }
6580
6581 return setPositiveNumber( elem, value, subtract );
6582 }
6583 };
6584} );
6585
6586jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
6587 function( elem, computed ) {
6588 if ( computed ) {
6589 return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
6590 elem.getBoundingClientRect().left -
6591 swap( elem, { marginLeft: 0 }, function() {
6592 return elem.getBoundingClientRect().left;
6593 } )
6594 ) + "px";
6595 }
6596 }
6597);
6598
6599// These hooks are used by animate to expand properties
6600jQuery.each( {
6601 margin: "",
6602 padding: "",
6603 border: "Width"
6604}, function( prefix, suffix ) {
6605 jQuery.cssHooks[ prefix + suffix ] = {
6606 expand: function( value ) {
6607 var i = 0,
6608 expanded = {},
6609
6610 // Assumes a single number if not a string
6611 parts = typeof value === "string" ? value.split( " " ) : [ value ];
6612
6613 for ( ; i < 4; i++ ) {
6614 expanded[ prefix + cssExpand[ i ] + suffix ] =
6615 parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
6616 }
6617
6618 return expanded;
6619 }
6620 };
6621
6622 if ( !rmargin.test( prefix ) ) {
6623 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
6624 }
6625} );
6626
6627jQuery.fn.extend( {
6628 css: function( name, value ) {
6629 return access( this, function( elem, name, value ) {
6630 var styles, len,
6631 map = {},
6632 i = 0;
6633
6634 if ( Array.isArray( name ) ) {
6635 styles = getStyles( elem );
6636 len = name.length;
6637
6638 for ( ; i < len; i++ ) {
6639 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
6640 }
6641
6642 return map;
6643 }
6644
6645 return value !== undefined ?
6646 jQuery.style( elem, name, value ) :
6647 jQuery.css( elem, name );
6648 }, name, value, arguments.length > 1 );
6649 }
6650} );
6651
6652
6653function Tween( elem, options, prop, end, easing ) {
6654 return new Tween.prototype.init( elem, options, prop, end, easing );
6655}
6656jQuery.Tween = Tween;
6657
6658Tween.prototype = {
6659 constructor: Tween,
6660 init: function( elem, options, prop, end, easing, unit ) {
6661 this.elem = elem;
6662 this.prop = prop;
6663 this.easing = easing || jQuery.easing._default;
6664 this.options = options;
6665 this.start = this.now = this.cur();
6666 this.end = end;
6667 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
6668 },
6669 cur: function() {
6670 var hooks = Tween.propHooks[ this.prop ];
6671
6672 return hooks && hooks.get ?
6673 hooks.get( this ) :
6674 Tween.propHooks._default.get( this );
6675 },
6676 run: function( percent ) {
6677 var eased,
6678 hooks = Tween.propHooks[ this.prop ];
6679
6680 if ( this.options.duration ) {
6681 this.pos = eased = jQuery.easing[ this.easing ](
6682 percent, this.options.duration * percent, 0, 1, this.options.duration
6683 );
6684 } else {
6685 this.pos = eased = percent;
6686 }
6687 this.now = ( this.end - this.start ) * eased + this.start;
6688
6689 if ( this.options.step ) {
6690 this.options.step.call( this.elem, this.now, this );
6691 }
6692
6693 if ( hooks && hooks.set ) {
6694 hooks.set( this );
6695 } else {
6696 Tween.propHooks._default.set( this );
6697 }
6698 return this;
6699 }
6700};
6701
6702Tween.prototype.init.prototype = Tween.prototype;
6703
6704Tween.propHooks = {
6705 _default: {
6706 get: function( tween ) {
6707 var result;
6708
6709 // Use a property on the element directly when it is not a DOM element,
6710 // or when there is no matching style property that exists.
6711 if ( tween.elem.nodeType !== 1 ||
6712 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
6713 return tween.elem[ tween.prop ];
6714 }
6715
6716 // Passing an empty string as a 3rd parameter to .css will automatically
6717 // attempt a parseFloat and fallback to a string if the parse fails.
6718 // Simple values such as "10px" are parsed to Float;
6719 // complex values such as "rotate(1rad)" are returned as-is.
6720 result = jQuery.css( tween.elem, tween.prop, "" );
6721
6722 // Empty strings, null, undefined and "auto" are converted to 0.
6723 return !result || result === "auto" ? 0 : result;
6724 },
6725 set: function( tween ) {
6726
6727 // Use step hook for back compat.
6728 // Use cssHook if its there.
6729 // Use .style if available and use plain properties where available.
6730 if ( jQuery.fx.step[ tween.prop ] ) {
6731 jQuery.fx.step[ tween.prop ]( tween );
6732 } else if ( tween.elem.nodeType === 1 &&
6733 ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
6734 jQuery.cssHooks[ tween.prop ] ) ) {
6735 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
6736 } else {
6737 tween.elem[ tween.prop ] = tween.now;
6738 }
6739 }
6740 }
6741};
6742
6743// Support: IE <=9 only
6744// Panic based approach to setting things on disconnected nodes
6745Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
6746 set: function( tween ) {
6747 if ( tween.elem.nodeType && tween.elem.parentNode ) {
6748 tween.elem[ tween.prop ] = tween.now;
6749 }
6750 }
6751};
6752
6753jQuery.easing = {
6754 linear: function( p ) {
6755 return p;
6756 },
6757 swing: function( p ) {
6758 return 0.5 - Math.cos( p * Math.PI ) / 2;
6759 },
6760 _default: "swing"
6761};
6762
6763jQuery.fx = Tween.prototype.init;
6764
6765// Back compat <1.8 extension point
6766jQuery.fx.step = {};
6767
6768
6769
6770
6771var
6772 fxNow, inProgress,
6773 rfxtypes = /^(?:toggle|show|hide)$/,
6774 rrun = /queueHooks$/;
6775
6776function schedule() {
6777 if ( inProgress ) {
6778 if ( document.hidden === false && window.requestAnimationFrame ) {
6779 window.requestAnimationFrame( schedule );
6780 } else {
6781 window.setTimeout( schedule, jQuery.fx.interval );
6782 }
6783
6784 jQuery.fx.tick();
6785 }
6786}
6787
6788// Animations created synchronously will run synchronously
6789function createFxNow() {
6790 window.setTimeout( function() {
6791 fxNow = undefined;
6792 } );
6793 return ( fxNow = jQuery.now() );
6794}
6795
6796// Generate parameters to create a standard animation
6797function genFx( type, includeWidth ) {
6798 var which,
6799 i = 0,
6800 attrs = { height: type };
6801
6802 // If we include width, step value is 1 to do all cssExpand values,
6803 // otherwise step value is 2 to skip over Left and Right
6804 includeWidth = includeWidth ? 1 : 0;
6805 for ( ; i < 4; i += 2 - includeWidth ) {
6806 which = cssExpand[ i ];
6807 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
6808 }
6809
6810 if ( includeWidth ) {
6811 attrs.opacity = attrs.width = type;
6812 }
6813
6814 return attrs;
6815}
6816
6817function createTween( value, prop, animation ) {
6818 var tween,
6819 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
6820 index = 0,
6821 length = collection.length;
6822 for ( ; index < length; index++ ) {
6823 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
6824
6825 // We're done with this property
6826 return tween;
6827 }
6828 }
6829}
6830
6831function defaultPrefilter( elem, props, opts ) {
6832 var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
6833 isBox = "width" in props || "height" in props,
6834 anim = this,
6835 orig = {},
6836 style = elem.style,
6837 hidden = elem.nodeType && isHiddenWithinTree( elem ),
6838 dataShow = dataPriv.get( elem, "fxshow" );
6839
6840 // Queue-skipping animations hijack the fx hooks
6841 if ( !opts.queue ) {
6842 hooks = jQuery._queueHooks( elem, "fx" );
6843 if ( hooks.unqueued == null ) {
6844 hooks.unqueued = 0;
6845 oldfire = hooks.empty.fire;
6846 hooks.empty.fire = function() {
6847 if ( !hooks.unqueued ) {
6848 oldfire();
6849 }
6850 };
6851 }
6852 hooks.unqueued++;
6853
6854 anim.always( function() {
6855
6856 // Ensure the complete handler is called before this completes
6857 anim.always( function() {
6858 hooks.unqueued--;
6859 if ( !jQuery.queue( elem, "fx" ).length ) {
6860 hooks.empty.fire();
6861 }
6862 } );
6863 } );
6864 }
6865
6866 // Detect show/hide animations
6867 for ( prop in props ) {
6868 value = props[ prop ];
6869 if ( rfxtypes.test( value ) ) {
6870 delete props[ prop ];
6871 toggle = toggle || value === "toggle";
6872 if ( value === ( hidden ? "hide" : "show" ) ) {
6873
6874 // Pretend to be hidden if this is a "show" and
6875 // there is still data from a stopped show/hide
6876 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
6877 hidden = true;
6878
6879 // Ignore all other no-op show/hide data
6880 } else {
6881 continue;
6882 }
6883 }
6884 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
6885 }
6886 }
6887
6888 // Bail out if this is a no-op like .hide().hide()
6889 propTween = !jQuery.isEmptyObject( props );
6890 if ( !propTween && jQuery.isEmptyObject( orig ) ) {
6891 return;
6892 }
6893
6894 // Restrict "overflow" and "display" styles during box animations
6895 if ( isBox && elem.nodeType === 1 ) {
6896
6897 // Support: IE <=9 - 11, Edge 12 - 13
6898 // Record all 3 overflow attributes because IE does not infer the shorthand
6899 // from identically-valued overflowX and overflowY
6900 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
6901
6902 // Identify a display type, preferring old show/hide data over the CSS cascade
6903 restoreDisplay = dataShow && dataShow.display;
6904 if ( restoreDisplay == null ) {
6905 restoreDisplay = dataPriv.get( elem, "display" );
6906 }
6907 display = jQuery.css( elem, "display" );
6908 if ( display === "none" ) {
6909 if ( restoreDisplay ) {
6910 display = restoreDisplay;
6911 } else {
6912
6913 // Get nonempty value(s) by temporarily forcing visibility
6914 showHide( [ elem ], true );
6915 restoreDisplay = elem.style.display || restoreDisplay;
6916 display = jQuery.css( elem, "display" );
6917 showHide( [ elem ] );
6918 }
6919 }
6920
6921 // Animate inline elements as inline-block
6922 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
6923 if ( jQuery.css( elem, "float" ) === "none" ) {
6924
6925 // Restore the original display value at the end of pure show/hide animations
6926 if ( !propTween ) {
6927 anim.done( function() {
6928 style.display = restoreDisplay;
6929 } );
6930 if ( restoreDisplay == null ) {
6931 display = style.display;
6932 restoreDisplay = display === "none" ? "" : display;
6933 }
6934 }
6935 style.display = "inline-block";
6936 }
6937 }
6938 }
6939
6940 if ( opts.overflow ) {
6941 style.overflow = "hidden";
6942 anim.always( function() {
6943 style.overflow = opts.overflow[ 0 ];
6944 style.overflowX = opts.overflow[ 1 ];
6945 style.overflowY = opts.overflow[ 2 ];
6946 } );
6947 }
6948
6949 // Implement show/hide animations
6950 propTween = false;
6951 for ( prop in orig ) {
6952
6953 // General show/hide setup for this element animation
6954 if ( !propTween ) {
6955 if ( dataShow ) {
6956 if ( "hidden" in dataShow ) {
6957 hidden = dataShow.hidden;
6958 }
6959 } else {
6960 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
6961 }
6962
6963 // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
6964 if ( toggle ) {
6965 dataShow.hidden = !hidden;
6966 }
6967
6968 // Show elements before animating them
6969 if ( hidden ) {
6970 showHide( [ elem ], true );
6971 }
6972
6973 /* eslint-disable no-loop-func */
6974
6975 anim.done( function() {
6976
6977 /* eslint-enable no-loop-func */
6978
6979 // The final step of a "hide" animation is actually hiding the element
6980 if ( !hidden ) {
6981 showHide( [ elem ] );
6982 }
6983 dataPriv.remove( elem, "fxshow" );
6984 for ( prop in orig ) {
6985 jQuery.style( elem, prop, orig[ prop ] );
6986 }
6987 } );
6988 }
6989
6990 // Per-property setup
6991 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
6992 if ( !( prop in dataShow ) ) {
6993 dataShow[ prop ] = propTween.start;
6994 if ( hidden ) {
6995 propTween.end = propTween.start;
6996 propTween.start = 0;
6997 }
6998 }
6999 }
7000}
7001
7002function propFilter( props, specialEasing ) {
7003 var index, name, easing, value, hooks;
7004
7005 // camelCase, specialEasing and expand cssHook pass
7006 for ( index in props ) {
7007 name = jQuery.camelCase( index );
7008 easing = specialEasing[ name ];
7009 value = props[ index ];
7010 if ( Array.isArray( value ) ) {
7011 easing = value[ 1 ];
7012 value = props[ index ] = value[ 0 ];
7013 }
7014
7015 if ( index !== name ) {
7016 props[ name ] = value;
7017 delete props[ index ];
7018 }
7019
7020 hooks = jQuery.cssHooks[ name ];
7021 if ( hooks && "expand" in hooks ) {
7022 value = hooks.expand( value );
7023 delete props[ name ];
7024
7025 // Not quite $.extend, this won't overwrite existing keys.
7026 // Reusing 'index' because we have the correct "name"
7027 for ( index in value ) {
7028 if ( !( index in props ) ) {
7029 props[ index ] = value[ index ];
7030 specialEasing[ index ] = easing;
7031 }
7032 }
7033 } else {
7034 specialEasing[ name ] = easing;
7035 }
7036 }
7037}
7038
7039function Animation( elem, properties, options ) {
7040 var result,
7041 stopped,
7042 index = 0,
7043 length = Animation.prefilters.length,
7044 deferred = jQuery.Deferred().always( function() {
7045
7046 // Don't match elem in the :animated selector
7047 delete tick.elem;
7048 } ),
7049 tick = function() {
7050 if ( stopped ) {
7051 return false;
7052 }
7053 var currentTime = fxNow || createFxNow(),
7054 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
7055
7056 // Support: Android 2.3 only
7057 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
7058 temp = remaining / animation.duration || 0,
7059 percent = 1 - temp,
7060 index = 0,
7061 length = animation.tweens.length;
7062
7063 for ( ; index < length; index++ ) {
7064 animation.tweens[ index ].run( percent );
7065 }
7066
7067 deferred.notifyWith( elem, [ animation, percent, remaining ] );
7068
7069 // If there's more to do, yield
7070 if ( percent < 1 && length ) {
7071 return remaining;
7072 }
7073
7074 // If this was an empty animation, synthesize a final progress notification
7075 if ( !length ) {
7076 deferred.notifyWith( elem, [ animation, 1, 0 ] );
7077 }
7078
7079 // Resolve the animation and report its conclusion
7080 deferred.resolveWith( elem, [ animation ] );
7081 return false;
7082 },
7083 animation = deferred.promise( {
7084 elem: elem,
7085 props: jQuery.extend( {}, properties ),
7086 opts: jQuery.extend( true, {
7087 specialEasing: {},
7088 easing: jQuery.easing._default
7089 }, options ),
7090 originalProperties: properties,
7091 originalOptions: options,
7092 startTime: fxNow || createFxNow(),
7093 duration: options.duration,
7094 tweens: [],
7095 createTween: function( prop, end ) {
7096 var tween = jQuery.Tween( elem, animation.opts, prop, end,
7097 animation.opts.specialEasing[ prop ] || animation.opts.easing );
7098 animation.tweens.push( tween );
7099 return tween;
7100 },
7101 stop: function( gotoEnd ) {
7102 var index = 0,
7103
7104 // If we are going to the end, we want to run all the tweens
7105 // otherwise we skip this part
7106 length = gotoEnd ? animation.tweens.length : 0;
7107 if ( stopped ) {
7108 return this;
7109 }
7110 stopped = true;
7111 for ( ; index < length; index++ ) {
7112 animation.tweens[ index ].run( 1 );
7113 }
7114
7115 // Resolve when we played the last frame; otherwise, reject
7116 if ( gotoEnd ) {
7117 deferred.notifyWith( elem, [ animation, 1, 0 ] );
7118 deferred.resolveWith( elem, [ animation, gotoEnd ] );
7119 } else {
7120 deferred.rejectWith( elem, [ animation, gotoEnd ] );
7121 }
7122 return this;
7123 }
7124 } ),
7125 props = animation.props;
7126
7127 propFilter( props, animation.opts.specialEasing );
7128
7129 for ( ; index < length; index++ ) {
7130 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
7131 if ( result ) {
7132 if ( jQuery.isFunction( result.stop ) ) {
7133 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
7134 jQuery.proxy( result.stop, result );
7135 }
7136 return result;
7137 }
7138 }
7139
7140 jQuery.map( props, createTween, animation );
7141
7142 if ( jQuery.isFunction( animation.opts.start ) ) {
7143 animation.opts.start.call( elem, animation );
7144 }
7145
7146 // Attach callbacks from options
7147 animation
7148 .progress( animation.opts.progress )
7149 .done( animation.opts.done, animation.opts.complete )
7150 .fail( animation.opts.fail )
7151 .always( animation.opts.always );
7152
7153 jQuery.fx.timer(
7154 jQuery.extend( tick, {
7155 elem: elem,
7156 anim: animation,
7157 queue: animation.opts.queue
7158 } )
7159 );
7160
7161 return animation;
7162}
7163
7164jQuery.Animation = jQuery.extend( Animation, {
7165
7166 tweeners: {
7167 "*": [ function( prop, value ) {
7168 var tween = this.createTween( prop, value );
7169 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
7170 return tween;
7171 } ]
7172 },
7173
7174 tweener: function( props, callback ) {
7175 if ( jQuery.isFunction( props ) ) {
7176 callback = props;
7177 props = [ "*" ];
7178 } else {
7179 props = props.match( rnothtmlwhite );
7180 }
7181
7182 var prop,
7183 index = 0,
7184 length = props.length;
7185
7186 for ( ; index < length; index++ ) {
7187 prop = props[ index ];
7188 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
7189 Animation.tweeners[ prop ].unshift( callback );
7190 }
7191 },
7192
7193 prefilters: [ defaultPrefilter ],
7194
7195 prefilter: function( callback, prepend ) {
7196 if ( prepend ) {
7197 Animation.prefilters.unshift( callback );
7198 } else {
7199 Animation.prefilters.push( callback );
7200 }
7201 }
7202} );
7203
7204jQuery.speed = function( speed, easing, fn ) {
7205 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
7206 complete: fn || !fn && easing ||
7207 jQuery.isFunction( speed ) && speed,
7208 duration: speed,
7209 easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
7210 };
7211
7212 // Go to the end state if fx are off
7213 if ( jQuery.fx.off ) {
7214 opt.duration = 0;
7215
7216 } else {
7217 if ( typeof opt.duration !== "number" ) {
7218 if ( opt.duration in jQuery.fx.speeds ) {
7219 opt.duration = jQuery.fx.speeds[ opt.duration ];
7220
7221 } else {
7222 opt.duration = jQuery.fx.speeds._default;
7223 }
7224 }
7225 }
7226
7227 // Normalize opt.queue - true/undefined/null -> "fx"
7228 if ( opt.queue == null || opt.queue === true ) {
7229 opt.queue = "fx";
7230 }
7231
7232 // Queueing
7233 opt.old = opt.complete;
7234
7235 opt.complete = function() {
7236 if ( jQuery.isFunction( opt.old ) ) {
7237 opt.old.call( this );
7238 }
7239
7240 if ( opt.queue ) {
7241 jQuery.dequeue( this, opt.queue );
7242 }
7243 };
7244
7245 return opt;
7246};
7247
7248jQuery.fn.extend( {
7249 fadeTo: function( speed, to, easing, callback ) {
7250
7251 // Show any hidden elements after setting opacity to 0
7252 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
7253
7254 // Animate to the value specified
7255 .end().animate( { opacity: to }, speed, easing, callback );
7256 },
7257 animate: function( prop, speed, easing, callback ) {
7258 var empty = jQuery.isEmptyObject( prop ),
7259 optall = jQuery.speed( speed, easing, callback ),
7260 doAnimation = function() {
7261
7262 // Operate on a copy of prop so per-property easing won't be lost
7263 var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7264
7265 // Empty animations, or finishing resolves immediately
7266 if ( empty || dataPriv.get( this, "finish" ) ) {
7267 anim.stop( true );
7268 }
7269 };
7270 doAnimation.finish = doAnimation;
7271
7272 return empty || optall.queue === false ?
7273 this.each( doAnimation ) :
7274 this.queue( optall.queue, doAnimation );
7275 },
7276 stop: function( type, clearQueue, gotoEnd ) {
7277 var stopQueue = function( hooks ) {
7278 var stop = hooks.stop;
7279 delete hooks.stop;
7280 stop( gotoEnd );
7281 };
7282
7283 if ( typeof type !== "string" ) {
7284 gotoEnd = clearQueue;
7285 clearQueue = type;
7286 type = undefined;
7287 }
7288 if ( clearQueue && type !== false ) {
7289 this.queue( type || "fx", [] );
7290 }
7291
7292 return this.each( function() {
7293 var dequeue = true,
7294 index = type != null && type + "queueHooks",
7295 timers = jQuery.timers,
7296 data = dataPriv.get( this );
7297
7298 if ( index ) {
7299 if ( data[ index ] && data[ index ].stop ) {
7300 stopQueue( data[ index ] );
7301 }
7302 } else {
7303 for ( index in data ) {
7304 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
7305 stopQueue( data[ index ] );
7306 }
7307 }
7308 }
7309
7310 for ( index = timers.length; index--; ) {
7311 if ( timers[ index ].elem === this &&
7312 ( type == null || timers[ index ].queue === type ) ) {
7313
7314 timers[ index ].anim.stop( gotoEnd );
7315 dequeue = false;
7316 timers.splice( index, 1 );
7317 }
7318 }
7319
7320 // Start the next in the queue if the last step wasn't forced.
7321 // Timers currently will call their complete callbacks, which
7322 // will dequeue but only if they were gotoEnd.
7323 if ( dequeue || !gotoEnd ) {
7324 jQuery.dequeue( this, type );
7325 }
7326 } );
7327 },
7328 finish: function( type ) {
7329 if ( type !== false ) {
7330 type = type || "fx";
7331 }
7332 return this.each( function() {
7333 var index,
7334 data = dataPriv.get( this ),
7335 queue = data[ type + "queue" ],
7336 hooks = data[ type + "queueHooks" ],
7337 timers = jQuery.timers,
7338 length = queue ? queue.length : 0;
7339
7340 // Enable finishing flag on private data
7341 data.finish = true;
7342
7343 // Empty the queue first
7344 jQuery.queue( this, type, [] );
7345
7346 if ( hooks && hooks.stop ) {
7347 hooks.stop.call( this, true );
7348 }
7349
7350 // Look for any active animations, and finish them
7351 for ( index = timers.length; index--; ) {
7352 if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
7353 timers[ index ].anim.stop( true );
7354 timers.splice( index, 1 );
7355 }
7356 }
7357
7358 // Look for any animations in the old queue and finish them
7359 for ( index = 0; index < length; index++ ) {
7360 if ( queue[ index ] && queue[ index ].finish ) {
7361 queue[ index ].finish.call( this );
7362 }
7363 }
7364
7365 // Turn off finishing flag
7366 delete data.finish;
7367 } );
7368 }
7369} );
7370
7371jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
7372 var cssFn = jQuery.fn[ name ];
7373 jQuery.fn[ name ] = function( speed, easing, callback ) {
7374 return speed == null || typeof speed === "boolean" ?
7375 cssFn.apply( this, arguments ) :
7376 this.animate( genFx( name, true ), speed, easing, callback );
7377 };
7378} );
7379
7380// Generate shortcuts for custom animations
7381jQuery.each( {
7382 slideDown: genFx( "show" ),
7383 slideUp: genFx( "hide" ),
7384 slideToggle: genFx( "toggle" ),
7385 fadeIn: { opacity: "show" },
7386 fadeOut: { opacity: "hide" },
7387 fadeToggle: { opacity: "toggle" }
7388}, function( name, props ) {
7389 jQuery.fn[ name ] = function( speed, easing, callback ) {
7390 return this.animate( props, speed, easing, callback );
7391 };
7392} );
7393
7394jQuery.timers = [];
7395jQuery.fx.tick = function() {
7396 var timer,
7397 i = 0,
7398 timers = jQuery.timers;
7399
7400 fxNow = jQuery.now();
7401
7402 for ( ; i < timers.length; i++ ) {
7403 timer = timers[ i ];
7404
7405 // Run the timer and safely remove it when done (allowing for external removal)
7406 if ( !timer() && timers[ i ] === timer ) {
7407 timers.splice( i--, 1 );
7408 }
7409 }
7410
7411 if ( !timers.length ) {
7412 jQuery.fx.stop();
7413 }
7414 fxNow = undefined;
7415};
7416
7417jQuery.fx.timer = function( timer ) {
7418 jQuery.timers.push( timer );
7419 jQuery.fx.start();
7420};
7421
7422jQuery.fx.interval = 13;
7423jQuery.fx.start = function() {
7424 if ( inProgress ) {
7425 return;
7426 }
7427
7428 inProgress = true;
7429 schedule();
7430};
7431
7432jQuery.fx.stop = function() {
7433 inProgress = null;
7434};
7435
7436jQuery.fx.speeds = {
7437 slow: 600,
7438 fast: 200,
7439
7440 // Default speed
7441 _default: 400
7442};
7443
7444
7445// Based off of the plugin by Clint Helfers, with permission.
7446// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
7447jQuery.fn.delay = function( time, type ) {
7448 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
7449 type = type || "fx";
7450
7451 return this.queue( type, function( next, hooks ) {
7452 var timeout = window.setTimeout( next, time );
7453 hooks.stop = function() {
7454 window.clearTimeout( timeout );
7455 };
7456 } );
7457};
7458
7459
7460( function() {
7461 var input = document.createElement( "input" ),
7462 select = document.createElement( "select" ),
7463 opt = select.appendChild( document.createElement( "option" ) );
7464
7465 input.type = "checkbox";
7466
7467 // Support: Android <=4.3 only
7468 // Default value for a checkbox should be "on"
7469 support.checkOn = input.value !== "";
7470
7471 // Support: IE <=11 only
7472 // Must access selectedIndex to make default options select
7473 support.optSelected = opt.selected;
7474
7475 // Support: IE <=11 only
7476 // An input loses its value after becoming a radio
7477 input = document.createElement( "input" );
7478 input.value = "t";
7479 input.type = "radio";
7480 support.radioValue = input.value === "t";
7481} )();
7482
7483
7484var boolHook,
7485 attrHandle = jQuery.expr.attrHandle;
7486
7487jQuery.fn.extend( {
7488 attr: function( name, value ) {
7489 return access( this, jQuery.attr, name, value, arguments.length > 1 );
7490 },
7491
7492 removeAttr: function( name ) {
7493 return this.each( function() {
7494 jQuery.removeAttr( this, name );
7495 } );
7496 }
7497} );
7498
7499jQuery.extend( {
7500 attr: function( elem, name, value ) {
7501 var ret, hooks,
7502 nType = elem.nodeType;
7503
7504 // Don't get/set attributes on text, comment and attribute nodes
7505 if ( nType === 3 || nType === 8 || nType === 2 ) {
7506 return;
7507 }
7508
7509 // Fallback to prop when attributes are not supported
7510 if ( typeof elem.getAttribute === "undefined" ) {
7511 return jQuery.prop( elem, name, value );
7512 }
7513
7514 // Attribute hooks are determined by the lowercase version
7515 // Grab necessary hook if one is defined
7516 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7517 hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
7518 ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
7519 }
7520
7521 if ( value !== undefined ) {
7522 if ( value === null ) {
7523 jQuery.removeAttr( elem, name );
7524 return;
7525 }
7526
7527 if ( hooks && "set" in hooks &&
7528 ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7529 return ret;
7530 }
7531
7532 elem.setAttribute( name, value + "" );
7533 return value;
7534 }
7535
7536 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7537 return ret;
7538 }
7539
7540 ret = jQuery.find.attr( elem, name );
7541
7542 // Non-existent attributes return null, we normalize to undefined
7543 return ret == null ? undefined : ret;
7544 },
7545
7546 attrHooks: {
7547 type: {
7548 set: function( elem, value ) {
7549 if ( !support.radioValue && value === "radio" &&
7550 nodeName( elem, "input" ) ) {
7551 var val = elem.value;
7552 elem.setAttribute( "type", value );
7553 if ( val ) {
7554 elem.value = val;
7555 }
7556 return value;
7557 }
7558 }
7559 }
7560 },
7561
7562 removeAttr: function( elem, value ) {
7563 var name,
7564 i = 0,
7565
7566 // Attribute names can contain non-HTML whitespace characters
7567 // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
7568 attrNames = value && value.match( rnothtmlwhite );
7569
7570 if ( attrNames && elem.nodeType === 1 ) {
7571 while ( ( name = attrNames[ i++ ] ) ) {
7572 elem.removeAttribute( name );
7573 }
7574 }
7575 }
7576} );
7577
7578// Hooks for boolean attributes
7579boolHook = {
7580 set: function( elem, value, name ) {
7581 if ( value === false ) {
7582
7583 // Remove boolean attributes when set to false
7584 jQuery.removeAttr( elem, name );
7585 } else {
7586 elem.setAttribute( name, name );
7587 }
7588 return name;
7589 }
7590};
7591
7592jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
7593 var getter = attrHandle[ name ] || jQuery.find.attr;
7594
7595 attrHandle[ name ] = function( elem, name, isXML ) {
7596 var ret, handle,
7597 lowercaseName = name.toLowerCase();
7598
7599 if ( !isXML ) {
7600
7601 // Avoid an infinite loop by temporarily removing this function from the getter
7602 handle = attrHandle[ lowercaseName ];
7603 attrHandle[ lowercaseName ] = ret;
7604 ret = getter( elem, name, isXML ) != null ?
7605 lowercaseName :
7606 null;
7607 attrHandle[ lowercaseName ] = handle;
7608 }
7609 return ret;
7610 };
7611} );
7612
7613
7614
7615
7616var rfocusable = /^(?:input|select|textarea|button)$/i,
7617 rclickable = /^(?:a|area)$/i;
7618
7619jQuery.fn.extend( {
7620 prop: function( name, value ) {
7621 return access( this, jQuery.prop, name, value, arguments.length > 1 );
7622 },
7623
7624 removeProp: function( name ) {
7625 return this.each( function() {
7626 delete this[ jQuery.propFix[ name ] || name ];
7627 } );
7628 }
7629} );
7630
7631jQuery.extend( {
7632 prop: function( elem, name, value ) {
7633 var ret, hooks,
7634 nType = elem.nodeType;
7635
7636 // Don't get/set properties on text, comment and attribute nodes
7637 if ( nType === 3 || nType === 8 || nType === 2 ) {
7638 return;
7639 }
7640
7641 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7642
7643 // Fix name and attach hooks
7644 name = jQuery.propFix[ name ] || name;
7645 hooks = jQuery.propHooks[ name ];
7646 }
7647
7648 if ( value !== undefined ) {
7649 if ( hooks && "set" in hooks &&
7650 ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7651 return ret;
7652 }
7653
7654 return ( elem[ name ] = value );
7655 }
7656
7657 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7658 return ret;
7659 }
7660
7661 return elem[ name ];
7662 },
7663
7664 propHooks: {
7665 tabIndex: {
7666 get: function( elem ) {
7667
7668 // Support: IE <=9 - 11 only
7669 // elem.tabIndex doesn't always return the
7670 // correct value when it hasn't been explicitly set
7671 // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
7672 // Use proper attribute retrieval(#12072)
7673 var tabindex = jQuery.find.attr( elem, "tabindex" );
7674
7675 if ( tabindex ) {
7676 return parseInt( tabindex, 10 );
7677 }
7678
7679 if (
7680 rfocusable.test( elem.nodeName ) ||
7681 rclickable.test( elem.nodeName ) &&
7682 elem.href
7683 ) {
7684 return 0;
7685 }
7686
7687 return -1;
7688 }
7689 }
7690 },
7691
7692 propFix: {
7693 "for": "htmlFor",
7694 "class": "className"
7695 }
7696} );
7697
7698// Support: IE <=11 only
7699// Accessing the selectedIndex property
7700// forces the browser to respect setting selected
7701// on the option
7702// The getter ensures a default option is selected
7703// when in an optgroup
7704// eslint rule "no-unused-expressions" is disabled for this code
7705// since it considers such accessions noop
7706if ( !support.optSelected ) {
7707 jQuery.propHooks.selected = {
7708 get: function( elem ) {
7709
7710 /* eslint no-unused-expressions: "off" */
7711
7712 var parent = elem.parentNode;
7713 if ( parent && parent.parentNode ) {
7714 parent.parentNode.selectedIndex;
7715 }
7716 return null;
7717 },
7718 set: function( elem ) {
7719
7720 /* eslint no-unused-expressions: "off" */
7721
7722 var parent = elem.parentNode;
7723 if ( parent ) {
7724 parent.selectedIndex;
7725
7726 if ( parent.parentNode ) {
7727 parent.parentNode.selectedIndex;
7728 }
7729 }
7730 }
7731 };
7732}
7733
7734jQuery.each( [
7735 "tabIndex",
7736 "readOnly",
7737 "maxLength",
7738 "cellSpacing",
7739 "cellPadding",
7740 "rowSpan",
7741 "colSpan",
7742 "useMap",
7743 "frameBorder",
7744 "contentEditable"
7745], function() {
7746 jQuery.propFix[ this.toLowerCase() ] = this;
7747} );
7748
7749
7750
7751
7752 // Strip and collapse whitespace according to HTML spec
7753 // https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
7754 function stripAndCollapse( value ) {
7755 var tokens = value.match( rnothtmlwhite ) || [];
7756 return tokens.join( " " );
7757 }
7758
7759
7760function getClass( elem ) {
7761 return elem.getAttribute && elem.getAttribute( "class" ) || "";
7762}
7763
7764jQuery.fn.extend( {
7765 addClass: function( value ) {
7766 var classes, elem, cur, curValue, clazz, j, finalValue,
7767 i = 0;
7768
7769 if ( jQuery.isFunction( value ) ) {
7770 return this.each( function( j ) {
7771 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
7772 } );
7773 }
7774
7775 if ( typeof value === "string" && value ) {
7776 classes = value.match( rnothtmlwhite ) || [];
7777
7778 while ( ( elem = this[ i++ ] ) ) {
7779 curValue = getClass( elem );
7780 cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
7781
7782 if ( cur ) {
7783 j = 0;
7784 while ( ( clazz = classes[ j++ ] ) ) {
7785 if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
7786 cur += clazz + " ";
7787 }
7788 }
7789
7790 // Only assign if different to avoid unneeded rendering.
7791 finalValue = stripAndCollapse( cur );
7792 if ( curValue !== finalValue ) {
7793 elem.setAttribute( "class", finalValue );
7794 }
7795 }
7796 }
7797 }
7798
7799 return this;
7800 },
7801
7802 removeClass: function( value ) {
7803 var classes, elem, cur, curValue, clazz, j, finalValue,
7804 i = 0;
7805
7806 if ( jQuery.isFunction( value ) ) {
7807 return this.each( function( j ) {
7808 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
7809 } );
7810 }
7811
7812 if ( !arguments.length ) {
7813 return this.attr( "class", "" );
7814 }
7815
7816 if ( typeof value === "string" && value ) {
7817 classes = value.match( rnothtmlwhite ) || [];
7818
7819 while ( ( elem = this[ i++ ] ) ) {
7820 curValue = getClass( elem );
7821
7822 // This expression is here for better compressibility (see addClass)
7823 cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
7824
7825 if ( cur ) {
7826 j = 0;
7827 while ( ( clazz = classes[ j++ ] ) ) {
7828
7829 // Remove *all* instances
7830 while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
7831 cur = cur.replace( " " + clazz + " ", " " );
7832 }
7833 }
7834
7835 // Only assign if different to avoid unneeded rendering.
7836 finalValue = stripAndCollapse( cur );
7837 if ( curValue !== finalValue ) {
7838 elem.setAttribute( "class", finalValue );
7839 }
7840 }
7841 }
7842 }
7843
7844 return this;
7845 },
7846
7847 toggleClass: function( value, stateVal ) {
7848 var type = typeof value;
7849
7850 if ( typeof stateVal === "boolean" && type === "string" ) {
7851 return stateVal ? this.addClass( value ) : this.removeClass( value );
7852 }
7853
7854 if ( jQuery.isFunction( value ) ) {
7855 return this.each( function( i ) {
7856 jQuery( this ).toggleClass(
7857 value.call( this, i, getClass( this ), stateVal ),
7858 stateVal
7859 );
7860 } );
7861 }
7862
7863 return this.each( function() {
7864 var className, i, self, classNames;
7865
7866 if ( type === "string" ) {
7867
7868 // Toggle individual class names
7869 i = 0;
7870 self = jQuery( this );
7871 classNames = value.match( rnothtmlwhite ) || [];
7872
7873 while ( ( className = classNames[ i++ ] ) ) {
7874
7875 // Check each className given, space separated list
7876 if ( self.hasClass( className ) ) {
7877 self.removeClass( className );
7878 } else {
7879 self.addClass( className );
7880 }
7881 }
7882
7883 // Toggle whole class name
7884 } else if ( value === undefined || type === "boolean" ) {
7885 className = getClass( this );
7886 if ( className ) {
7887
7888 // Store className if set
7889 dataPriv.set( this, "__className__", className );
7890 }
7891
7892 // If the element has a class name or if we're passed `false`,
7893 // then remove the whole classname (if there was one, the above saved it).
7894 // Otherwise bring back whatever was previously saved (if anything),
7895 // falling back to the empty string if nothing was stored.
7896 if ( this.setAttribute ) {
7897 this.setAttribute( "class",
7898 className || value === false ?
7899 "" :
7900 dataPriv.get( this, "__className__" ) || ""
7901 );
7902 }
7903 }
7904 } );
7905 },
7906
7907 hasClass: function( selector ) {
7908 var className, elem,
7909 i = 0;
7910
7911 className = " " + selector + " ";
7912 while ( ( elem = this[ i++ ] ) ) {
7913 if ( elem.nodeType === 1 &&
7914 ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
7915 return true;
7916 }
7917 }
7918
7919 return false;
7920 }
7921} );
7922
7923
7924
7925
7926var rreturn = /\r/g;
7927
7928jQuery.fn.extend( {
7929 val: function( value ) {
7930 var hooks, ret, isFunction,
7931 elem = this[ 0 ];
7932
7933 if ( !arguments.length ) {
7934 if ( elem ) {
7935 hooks = jQuery.valHooks[ elem.type ] ||
7936 jQuery.valHooks[ elem.nodeName.toLowerCase() ];
7937
7938 if ( hooks &&
7939 "get" in hooks &&
7940 ( ret = hooks.get( elem, "value" ) ) !== undefined
7941 ) {
7942 return ret;
7943 }
7944
7945 ret = elem.value;
7946
7947 // Handle most common string cases
7948 if ( typeof ret === "string" ) {
7949 return ret.replace( rreturn, "" );
7950 }
7951
7952 // Handle cases where value is null/undef or number
7953 return ret == null ? "" : ret;
7954 }
7955
7956 return;
7957 }
7958
7959 isFunction = jQuery.isFunction( value );
7960
7961 return this.each( function( i ) {
7962 var val;
7963
7964 if ( this.nodeType !== 1 ) {
7965 return;
7966 }
7967
7968 if ( isFunction ) {
7969 val = value.call( this, i, jQuery( this ).val() );
7970 } else {
7971 val = value;
7972 }
7973
7974 // Treat null/undefined as ""; convert numbers to string
7975 if ( val == null ) {
7976 val = "";
7977
7978 } else if ( typeof val === "number" ) {
7979 val += "";
7980
7981 } else if ( Array.isArray( val ) ) {
7982 val = jQuery.map( val, function( value ) {
7983 return value == null ? "" : value + "";
7984 } );
7985 }
7986
7987 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
7988
7989 // If set returns undefined, fall back to normal setting
7990 if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
7991 this.value = val;
7992 }
7993 } );
7994 }
7995} );
7996
7997jQuery.extend( {
7998 valHooks: {
7999 option: {
8000 get: function( elem ) {
8001
8002 var val = jQuery.find.attr( elem, "value" );
8003 return val != null ?
8004 val :
8005
8006 // Support: IE <=10 - 11 only
8007 // option.text throws exceptions (#14686, #14858)
8008 // Strip and collapse whitespace
8009 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
8010 stripAndCollapse( jQuery.text( elem ) );
8011 }
8012 },
8013 select: {
8014 get: function( elem ) {
8015 var value, option, i,
8016 options = elem.options,
8017 index = elem.selectedIndex,
8018 one = elem.type === "select-one",
8019 values = one ? null : [],
8020 max = one ? index + 1 : options.length;
8021
8022 if ( index < 0 ) {
8023 i = max;
8024
8025 } else {
8026 i = one ? index : 0;
8027 }
8028
8029 // Loop through all the selected options
8030 for ( ; i < max; i++ ) {
8031 option = options[ i ];
8032
8033 // Support: IE <=9 only
8034 // IE8-9 doesn't update selected after form reset (#2551)
8035 if ( ( option.selected || i === index ) &&
8036
8037 // Don't return options that are disabled or in a disabled optgroup
8038 !option.disabled &&
8039 ( !option.parentNode.disabled ||
8040 !nodeName( option.parentNode, "optgroup" ) ) ) {
8041
8042 // Get the specific value for the option
8043 value = jQuery( option ).val();
8044
8045 // We don't need an array for one selects
8046 if ( one ) {
8047 return value;
8048 }
8049
8050 // Multi-Selects return an array
8051 values.push( value );
8052 }
8053 }
8054
8055 return values;
8056 },
8057
8058 set: function( elem, value ) {
8059 var optionSet, option,
8060 options = elem.options,
8061 values = jQuery.makeArray( value ),
8062 i = options.length;
8063
8064 while ( i-- ) {
8065 option = options[ i ];
8066
8067 /* eslint-disable no-cond-assign */
8068
8069 if ( option.selected =
8070 jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
8071 ) {
8072 optionSet = true;
8073 }
8074
8075 /* eslint-enable no-cond-assign */
8076 }
8077
8078 // Force browsers to behave consistently when non-matching value is set
8079 if ( !optionSet ) {
8080 elem.selectedIndex = -1;
8081 }
8082 return values;
8083 }
8084 }
8085 }
8086} );
8087
8088// Radios and checkboxes getter/setter
8089jQuery.each( [ "radio", "checkbox" ], function() {
8090 jQuery.valHooks[ this ] = {
8091 set: function( elem, value ) {
8092 if ( Array.isArray( value ) ) {
8093 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
8094 }
8095 }
8096 };
8097 if ( !support.checkOn ) {
8098 jQuery.valHooks[ this ].get = function( elem ) {
8099 return elem.getAttribute( "value" ) === null ? "on" : elem.value;
8100 };
8101 }
8102} );
8103
8104
8105
8106
8107// Return jQuery for attributes-only inclusion
8108
8109
8110var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
8111
8112jQuery.extend( jQuery.event, {
8113
8114 trigger: function( event, data, elem, onlyHandlers ) {
8115
8116 var i, cur, tmp, bubbleType, ontype, handle, special,
8117 eventPath = [ elem || document ],
8118 type = hasOwn.call( event, "type" ) ? event.type : event,
8119 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
8120
8121 cur = tmp = elem = elem || document;
8122
8123 // Don't do events on text and comment nodes
8124 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
8125 return;
8126 }
8127
8128 // focus/blur morphs to focusin/out; ensure we're not firing them right now
8129 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
8130 return;
8131 }
8132
8133 if ( type.indexOf( "." ) > -1 ) {
8134
8135 // Namespaced trigger; create a regexp to match event type in handle()
8136 namespaces = type.split( "." );
8137 type = namespaces.shift();
8138 namespaces.sort();
8139 }
8140 ontype = type.indexOf( ":" ) < 0 && "on" + type;
8141
8142 // Caller can pass in a jQuery.Event object, Object, or just an event type string
8143 event = event[ jQuery.expando ] ?
8144 event :
8145 new jQuery.Event( type, typeof event === "object" && event );
8146
8147 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
8148 event.isTrigger = onlyHandlers ? 2 : 3;
8149 event.namespace = namespaces.join( "." );
8150 event.rnamespace = event.namespace ?
8151 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
8152 null;
8153
8154 // Clean up the event in case it is being reused
8155 event.result = undefined;
8156 if ( !event.target ) {
8157 event.target = elem;
8158 }
8159
8160 // Clone any incoming data and prepend the event, creating the handler arg list
8161 data = data == null ?
8162 [ event ] :
8163 jQuery.makeArray( data, [ event ] );
8164
8165 // Allow special events to draw outside the lines
8166 special = jQuery.event.special[ type ] || {};
8167 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
8168 return;
8169 }
8170
8171 // Determine event propagation path in advance, per W3C events spec (#9951)
8172 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
8173 if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
8174
8175 bubbleType = special.delegateType || type;
8176 if ( !rfocusMorph.test( bubbleType + type ) ) {
8177 cur = cur.parentNode;
8178 }
8179 for ( ; cur; cur = cur.parentNode ) {
8180 eventPath.push( cur );
8181 tmp = cur;
8182 }
8183
8184 // Only add window if we got to document (e.g., not plain obj or detached DOM)
8185 if ( tmp === ( elem.ownerDocument || document ) ) {
8186 eventPath.push( tmp.defaultView || tmp.parentWindow || window );
8187 }
8188 }
8189
8190 // Fire handlers on the event path
8191 i = 0;
8192 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
8193
8194 event.type = i > 1 ?
8195 bubbleType :
8196 special.bindType || type;
8197
8198 // jQuery handler
8199 handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
8200 dataPriv.get( cur, "handle" );
8201 if ( handle ) {
8202 handle.apply( cur, data );
8203 }
8204
8205 // Native handler
8206 handle = ontype && cur[ ontype ];
8207 if ( handle && handle.apply && acceptData( cur ) ) {
8208 event.result = handle.apply( cur, data );
8209 if ( event.result === false ) {
8210 event.preventDefault();
8211 }
8212 }
8213 }
8214 event.type = type;
8215
8216 // If nobody prevented the default action, do it now
8217 if ( !onlyHandlers && !event.isDefaultPrevented() ) {
8218
8219 if ( ( !special._default ||
8220 special._default.apply( eventPath.pop(), data ) === false ) &&
8221 acceptData( elem ) ) {
8222
8223 // Call a native DOM method on the target with the same name as the event.
8224 // Don't do default actions on window, that's where global variables be (#6170)
8225 if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
8226
8227 // Don't re-trigger an onFOO event when we call its FOO() method
8228 tmp = elem[ ontype ];
8229
8230 if ( tmp ) {
8231 elem[ ontype ] = null;
8232 }
8233
8234 // Prevent re-triggering of the same event, since we already bubbled it above
8235 jQuery.event.triggered = type;
8236 elem[ type ]();
8237 jQuery.event.triggered = undefined;
8238
8239 if ( tmp ) {
8240 elem[ ontype ] = tmp;
8241 }
8242 }
8243 }
8244 }
8245
8246 return event.result;
8247 },
8248
8249 // Piggyback on a donor event to simulate a different one
8250 // Used only for `focus(in | out)` events
8251 simulate: function( type, elem, event ) {
8252 var e = jQuery.extend(
8253 new jQuery.Event(),
8254 event,
8255 {
8256 type: type,
8257 isSimulated: true
8258 }
8259 );
8260
8261 jQuery.event.trigger( e, null, elem );
8262 }
8263
8264} );
8265
8266jQuery.fn.extend( {
8267
8268 trigger: function( type, data ) {
8269 return this.each( function() {
8270 jQuery.event.trigger( type, data, this );
8271 } );
8272 },
8273 triggerHandler: function( type, data ) {
8274 var elem = this[ 0 ];
8275 if ( elem ) {
8276 return jQuery.event.trigger( type, data, elem, true );
8277 }
8278 }
8279} );
8280
8281
8282jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
8283 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
8284 "change select submit keydown keypress keyup contextmenu" ).split( " " ),
8285 function( i, name ) {
8286
8287 // Handle event binding
8288 jQuery.fn[ name ] = function( data, fn ) {
8289 return arguments.length > 0 ?
8290 this.on( name, null, data, fn ) :
8291 this.trigger( name );
8292 };
8293} );
8294
8295jQuery.fn.extend( {
8296 hover: function( fnOver, fnOut ) {
8297 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
8298 }
8299} );
8300
8301
8302
8303
8304support.focusin = "onfocusin" in window;
8305
8306
8307// Support: Firefox <=44
8308// Firefox doesn't have focus(in | out) events
8309// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
8310//
8311// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
8312// focus(in | out) events fire after focus & blur events,
8313// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
8314// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
8315if ( !support.focusin ) {
8316 jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
8317
8318 // Attach a single capturing handler on the document while someone wants focusin/focusout
8319 var handler = function( event ) {
8320 jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
8321 };
8322
8323 jQuery.event.special[ fix ] = {
8324 setup: function() {
8325 var doc = this.ownerDocument || this,
8326 attaches = dataPriv.access( doc, fix );
8327
8328 if ( !attaches ) {
8329 doc.addEventListener( orig, handler, true );
8330 }
8331 dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
8332 },
8333 teardown: function() {
8334 var doc = this.ownerDocument || this,
8335 attaches = dataPriv.access( doc, fix ) - 1;
8336
8337 if ( !attaches ) {
8338 doc.removeEventListener( orig, handler, true );
8339 dataPriv.remove( doc, fix );
8340
8341 } else {
8342 dataPriv.access( doc, fix, attaches );
8343 }
8344 }
8345 };
8346 } );
8347}
8348var location = window.location;
8349
8350var nonce = jQuery.now();
8351
8352var rquery = ( /\?/ );
8353
8354
8355
8356// Cross-browser xml parsing
8357jQuery.parseXML = function( data ) {
8358 var xml;
8359 if ( !data || typeof data !== "string" ) {
8360 return null;
8361 }
8362
8363 // Support: IE 9 - 11 only
8364 // IE throws on parseFromString with invalid input.
8365 try {
8366 xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
8367 } catch ( e ) {
8368 xml = undefined;
8369 }
8370
8371 if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
8372 jQuery.error( "Invalid XML: " + data );
8373 }
8374 return xml;
8375};
8376
8377
8378var
8379 rbracket = /\[\]$/,
8380 rCRLF = /\r?\n/g,
8381 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
8382 rsubmittable = /^(?:input|select|textarea|keygen)/i;
8383
8384function buildParams( prefix, obj, traditional, add ) {
8385 var name;
8386
8387 if ( Array.isArray( obj ) ) {
8388
8389 // Serialize array item.
8390 jQuery.each( obj, function( i, v ) {
8391 if ( traditional || rbracket.test( prefix ) ) {
8392
8393 // Treat each array item as a scalar.
8394 add( prefix, v );
8395
8396 } else {
8397
8398 // Item is non-scalar (array or object), encode its numeric index.
8399 buildParams(
8400 prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
8401 v,
8402 traditional,
8403 add
8404 );
8405 }
8406 } );
8407
8408 } else if ( !traditional && jQuery.type( obj ) === "object" ) {
8409
8410 // Serialize object item.
8411 for ( name in obj ) {
8412 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
8413 }
8414
8415 } else {
8416
8417 // Serialize scalar item.
8418 add( prefix, obj );
8419 }
8420}
8421
8422// Serialize an array of form elements or a set of
8423// key/values into a query string
8424jQuery.param = function( a, traditional ) {
8425 var prefix,
8426 s = [],
8427 add = function( key, valueOrFunction ) {
8428
8429 // If value is a function, invoke it and use its return value
8430 var value = jQuery.isFunction( valueOrFunction ) ?
8431 valueOrFunction() :
8432 valueOrFunction;
8433
8434 s[ s.length ] = encodeURIComponent( key ) + "=" +
8435 encodeURIComponent( value == null ? "" : value );
8436 };
8437
8438 // If an array was passed in, assume that it is an array of form elements.
8439 if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
8440
8441 // Serialize the form elements
8442 jQuery.each( a, function() {
8443 add( this.name, this.value );
8444 } );
8445
8446 } else {
8447
8448 // If traditional, encode the "old" way (the way 1.3.2 or older
8449 // did it), otherwise encode params recursively.
8450 for ( prefix in a ) {
8451 buildParams( prefix, a[ prefix ], traditional, add );
8452 }
8453 }
8454
8455 // Return the resulting serialization
8456 return s.join( "&" );
8457};
8458
8459jQuery.fn.extend( {
8460 serialize: function() {
8461 return jQuery.param( this.serializeArray() );
8462 },
8463 serializeArray: function() {
8464 return this.map( function() {
8465
8466 // Can add propHook for "elements" to filter or add form elements
8467 var elements = jQuery.prop( this, "elements" );
8468 return elements ? jQuery.makeArray( elements ) : this;
8469 } )
8470 .filter( function() {
8471 var type = this.type;
8472
8473 // Use .is( ":disabled" ) so that fieldset[disabled] works
8474 return this.name && !jQuery( this ).is( ":disabled" ) &&
8475 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
8476 ( this.checked || !rcheckableType.test( type ) );
8477 } )
8478 .map( function( i, elem ) {
8479 var val = jQuery( this ).val();
8480
8481 if ( val == null ) {
8482 return null;
8483 }
8484
8485 if ( Array.isArray( val ) ) {
8486 return jQuery.map( val, function( val ) {
8487 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8488 } );
8489 }
8490
8491 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8492 } ).get();
8493 }
8494} );
8495
8496
8497var
8498 r20 = /%20/g,
8499 rhash = /#.*$/,
8500 rantiCache = /([?&])_=[^&]*/,
8501 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
8502
8503 // #7653, #8125, #8152: local protocol detection
8504 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
8505 rnoContent = /^(?:GET|HEAD)$/,
8506 rprotocol = /^\/\//,
8507
8508 /* Prefilters
8509 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
8510 * 2) These are called:
8511 * - BEFORE asking for a transport
8512 * - AFTER param serialization (s.data is a string if s.processData is true)
8513 * 3) key is the dataType
8514 * 4) the catchall symbol "*" can be used
8515 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
8516 */
8517 prefilters = {},
8518
8519 /* Transports bindings
8520 * 1) key is the dataType
8521 * 2) the catchall symbol "*" can be used
8522 * 3) selection will start with transport dataType and THEN go to "*" if needed
8523 */
8524 transports = {},
8525
8526 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
8527 allTypes = "*/".concat( "*" ),
8528
8529 // Anchor tag for parsing the document origin
8530 originAnchor = document.createElement( "a" );
8531 originAnchor.href = location.href;
8532
8533// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
8534function addToPrefiltersOrTransports( structure ) {
8535
8536 // dataTypeExpression is optional and defaults to "*"
8537 return function( dataTypeExpression, func ) {
8538
8539 if ( typeof dataTypeExpression !== "string" ) {
8540 func = dataTypeExpression;
8541 dataTypeExpression = "*";
8542 }
8543
8544 var dataType,
8545 i = 0,
8546 dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
8547
8548 if ( jQuery.isFunction( func ) ) {
8549
8550 // For each dataType in the dataTypeExpression
8551 while ( ( dataType = dataTypes[ i++ ] ) ) {
8552
8553 // Prepend if requested
8554 if ( dataType[ 0 ] === "+" ) {
8555 dataType = dataType.slice( 1 ) || "*";
8556 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
8557
8558 // Otherwise append
8559 } else {
8560 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
8561 }
8562 }
8563 }
8564 };
8565}
8566
8567// Base inspection function for prefilters and transports
8568function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
8569
8570 var inspected = {},
8571 seekingTransport = ( structure === transports );
8572
8573 function inspect( dataType ) {
8574 var selected;
8575 inspected[ dataType ] = true;
8576 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
8577 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
8578 if ( typeof dataTypeOrTransport === "string" &&
8579 !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
8580
8581 options.dataTypes.unshift( dataTypeOrTransport );
8582 inspect( dataTypeOrTransport );
8583 return false;
8584 } else if ( seekingTransport ) {
8585 return !( selected = dataTypeOrTransport );
8586 }
8587 } );
8588 return selected;
8589 }
8590
8591 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
8592}
8593
8594// A special extend for ajax options
8595// that takes "flat" options (not to be deep extended)
8596// Fixes #9887
8597function ajaxExtend( target, src ) {
8598 var key, deep,
8599 flatOptions = jQuery.ajaxSettings.flatOptions || {};
8600
8601 for ( key in src ) {
8602 if ( src[ key ] !== undefined ) {
8603 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
8604 }
8605 }
8606 if ( deep ) {
8607 jQuery.extend( true, target, deep );
8608 }
8609
8610 return target;
8611}
8612
8613/* Handles responses to an ajax request:
8614 * - finds the right dataType (mediates between content-type and expected dataType)
8615 * - returns the corresponding response
8616 */
8617function ajaxHandleResponses( s, jqXHR, responses ) {
8618
8619 var ct, type, finalDataType, firstDataType,
8620 contents = s.contents,
8621 dataTypes = s.dataTypes;
8622
8623 // Remove auto dataType and get content-type in the process
8624 while ( dataTypes[ 0 ] === "*" ) {
8625 dataTypes.shift();
8626 if ( ct === undefined ) {
8627 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
8628 }
8629 }
8630
8631 // Check if we're dealing with a known content-type
8632 if ( ct ) {
8633 for ( type in contents ) {
8634 if ( contents[ type ] && contents[ type ].test( ct ) ) {
8635 dataTypes.unshift( type );
8636 break;
8637 }
8638 }
8639 }
8640
8641 // Check to see if we have a response for the expected dataType
8642 if ( dataTypes[ 0 ] in responses ) {
8643 finalDataType = dataTypes[ 0 ];
8644 } else {
8645
8646 // Try convertible dataTypes
8647 for ( type in responses ) {
8648 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
8649 finalDataType = type;
8650 break;
8651 }
8652 if ( !firstDataType ) {
8653 firstDataType = type;
8654 }
8655 }
8656
8657 // Or just use first one
8658 finalDataType = finalDataType || firstDataType;
8659 }
8660
8661 // If we found a dataType
8662 // We add the dataType to the list if needed
8663 // and return the corresponding response
8664 if ( finalDataType ) {
8665 if ( finalDataType !== dataTypes[ 0 ] ) {
8666 dataTypes.unshift( finalDataType );
8667 }
8668 return responses[ finalDataType ];
8669 }
8670}
8671
8672/* Chain conversions given the request and the original response
8673 * Also sets the responseXXX fields on the jqXHR instance
8674 */
8675function ajaxConvert( s, response, jqXHR, isSuccess ) {
8676 var conv2, current, conv, tmp, prev,
8677 converters = {},
8678
8679 // Work with a copy of dataTypes in case we need to modify it for conversion
8680 dataTypes = s.dataTypes.slice();
8681
8682 // Create converters map with lowercased keys
8683 if ( dataTypes[ 1 ] ) {
8684 for ( conv in s.converters ) {
8685 converters[ conv.toLowerCase() ] = s.converters[ conv ];
8686 }
8687 }
8688
8689 current = dataTypes.shift();
8690
8691 // Convert to each sequential dataType
8692 while ( current ) {
8693
8694 if ( s.responseFields[ current ] ) {
8695 jqXHR[ s.responseFields[ current ] ] = response;
8696 }
8697
8698 // Apply the dataFilter if provided
8699 if ( !prev && isSuccess && s.dataFilter ) {
8700 response = s.dataFilter( response, s.dataType );
8701 }
8702
8703 prev = current;
8704 current = dataTypes.shift();
8705
8706 if ( current ) {
8707
8708 // There's only work to do if current dataType is non-auto
8709 if ( current === "*" ) {
8710
8711 current = prev;
8712
8713 // Convert response if prev dataType is non-auto and differs from current
8714 } else if ( prev !== "*" && prev !== current ) {
8715
8716 // Seek a direct converter
8717 conv = converters[ prev + " " + current ] || converters[ "* " + current ];
8718
8719 // If none found, seek a pair
8720 if ( !conv ) {
8721 for ( conv2 in converters ) {
8722
8723 // If conv2 outputs current
8724 tmp = conv2.split( " " );
8725 if ( tmp[ 1 ] === current ) {
8726
8727 // If prev can be converted to accepted input
8728 conv = converters[ prev + " " + tmp[ 0 ] ] ||
8729 converters[ "* " + tmp[ 0 ] ];
8730 if ( conv ) {
8731
8732 // Condense equivalence converters
8733 if ( conv === true ) {
8734 conv = converters[ conv2 ];
8735
8736 // Otherwise, insert the intermediate dataType
8737 } else if ( converters[ conv2 ] !== true ) {
8738 current = tmp[ 0 ];
8739 dataTypes.unshift( tmp[ 1 ] );
8740 }
8741 break;
8742 }
8743 }
8744 }
8745 }
8746
8747 // Apply converter (if not an equivalence)
8748 if ( conv !== true ) {
8749
8750 // Unless errors are allowed to bubble, catch and return them
8751 if ( conv && s.throws ) {
8752 response = conv( response );
8753 } else {
8754 try {
8755 response = conv( response );
8756 } catch ( e ) {
8757 return {
8758 state: "parsererror",
8759 error: conv ? e : "No conversion from " + prev + " to " + current
8760 };
8761 }
8762 }
8763 }
8764 }
8765 }
8766 }
8767
8768 return { state: "success", data: response };
8769}
8770
8771jQuery.extend( {
8772
8773 // Counter for holding the number of active queries
8774 active: 0,
8775
8776 // Last-Modified header cache for next request
8777 lastModified: {},
8778 etag: {},
8779
8780 ajaxSettings: {
8781 url: location.href,
8782 type: "GET",
8783 isLocal: rlocalProtocol.test( location.protocol ),
8784 global: true,
8785 processData: true,
8786 async: true,
8787 contentType: "application/x-www-form-urlencoded; charset=UTF-8",
8788
8789 /*
8790 timeout: 0,
8791 data: null,
8792 dataType: null,
8793 username: null,
8794 password: null,
8795 cache: null,
8796 throws: false,
8797 traditional: false,
8798 headers: {},
8799 */
8800
8801 accepts: {
8802 "*": allTypes,
8803 text: "text/plain",
8804 html: "text/html",
8805 xml: "application/xml, text/xml",
8806 json: "application/json, text/javascript"
8807 },
8808
8809 contents: {
8810 xml: /\bxml\b/,
8811 html: /\bhtml/,
8812 json: /\bjson\b/
8813 },
8814
8815 responseFields: {
8816 xml: "responseXML",
8817 text: "responseText",
8818 json: "responseJSON"
8819 },
8820
8821 // Data converters
8822 // Keys separate source (or catchall "*") and destination types with a single space
8823 converters: {
8824
8825 // Convert anything to text
8826 "* text": String,
8827
8828 // Text to html (true = no transformation)
8829 "text html": true,
8830
8831 // Evaluate text as a json expression
8832 "text json": JSON.parse,
8833
8834 // Parse text as xml
8835 "text xml": jQuery.parseXML
8836 },
8837
8838 // For options that shouldn't be deep extended:
8839 // you can add your own custom options here if
8840 // and when you create one that shouldn't be
8841 // deep extended (see ajaxExtend)
8842 flatOptions: {
8843 url: true,
8844 context: true
8845 }
8846 },
8847
8848 // Creates a full fledged settings object into target
8849 // with both ajaxSettings and settings fields.
8850 // If target is omitted, writes into ajaxSettings.
8851 ajaxSetup: function( target, settings ) {
8852 return settings ?
8853
8854 // Building a settings object
8855 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
8856
8857 // Extending ajaxSettings
8858 ajaxExtend( jQuery.ajaxSettings, target );
8859 },
8860
8861 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
8862 ajaxTransport: addToPrefiltersOrTransports( transports ),
8863
8864 // Main method
8865 ajax: function( url, options ) {
8866
8867 // If url is an object, simulate pre-1.5 signature
8868 if ( typeof url === "object" ) {
8869 options = url;
8870 url = undefined;
8871 }
8872
8873 // Force options to be an object
8874 options = options || {};
8875
8876 var transport,
8877
8878 // URL without anti-cache param
8879 cacheURL,
8880
8881 // Response headers
8882 responseHeadersString,
8883 responseHeaders,
8884
8885 // timeout handle
8886 timeoutTimer,
8887
8888 // Url cleanup var
8889 urlAnchor,
8890
8891 // Request state (becomes false upon send and true upon completion)
8892 completed,
8893
8894 // To know if global events are to be dispatched
8895 fireGlobals,
8896
8897 // Loop variable
8898 i,
8899
8900 // uncached part of the url
8901 uncached,
8902
8903 // Create the final options object
8904 s = jQuery.ajaxSetup( {}, options ),
8905
8906 // Callbacks context
8907 callbackContext = s.context || s,
8908
8909 // Context for global events is callbackContext if it is a DOM node or jQuery collection
8910 globalEventContext = s.context &&
8911 ( callbackContext.nodeType || callbackContext.jquery ) ?
8912 jQuery( callbackContext ) :
8913 jQuery.event,
8914
8915 // Deferreds
8916 deferred = jQuery.Deferred(),
8917 completeDeferred = jQuery.Callbacks( "once memory" ),
8918
8919 // Status-dependent callbacks
8920 statusCode = s.statusCode || {},
8921
8922 // Headers (they are sent all at once)
8923 requestHeaders = {},
8924 requestHeadersNames = {},
8925
8926 // Default abort message
8927 strAbort = "canceled",
8928
8929 // Fake xhr
8930 jqXHR = {
8931 readyState: 0,
8932
8933 // Builds headers hashtable if needed
8934 getResponseHeader: function( key ) {
8935 var match;
8936 if ( completed ) {
8937 if ( !responseHeaders ) {
8938 responseHeaders = {};
8939 while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
8940 responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
8941 }
8942 }
8943 match = responseHeaders[ key.toLowerCase() ];
8944 }
8945 return match == null ? null : match;
8946 },
8947
8948 // Raw string
8949 getAllResponseHeaders: function() {
8950 return completed ? responseHeadersString : null;
8951 },
8952
8953 // Caches the header
8954 setRequestHeader: function( name, value ) {
8955 if ( completed == null ) {
8956 name = requestHeadersNames[ name.toLowerCase() ] =
8957 requestHeadersNames[ name.toLowerCase() ] || name;
8958 requestHeaders[ name ] = value;
8959 }
8960 return this;
8961 },
8962
8963 // Overrides response content-type header
8964 overrideMimeType: function( type ) {
8965 if ( completed == null ) {
8966 s.mimeType = type;
8967 }
8968 return this;
8969 },
8970
8971 // Status-dependent callbacks
8972 statusCode: function( map ) {
8973 var code;
8974 if ( map ) {
8975 if ( completed ) {
8976
8977 // Execute the appropriate callbacks
8978 jqXHR.always( map[ jqXHR.status ] );
8979 } else {
8980
8981 // Lazy-add the new callbacks in a way that preserves old ones
8982 for ( code in map ) {
8983 statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
8984 }
8985 }
8986 }
8987 return this;
8988 },
8989
8990 // Cancel the request
8991 abort: function( statusText ) {
8992 var finalText = statusText || strAbort;
8993 if ( transport ) {
8994 transport.abort( finalText );
8995 }
8996 done( 0, finalText );
8997 return this;
8998 }
8999 };
9000
9001 // Attach deferreds
9002 deferred.promise( jqXHR );
9003
9004 // Add protocol if not provided (prefilters might expect it)
9005 // Handle falsy url in the settings object (#10093: consistency with old signature)
9006 // We also use the url parameter if available
9007 s.url = ( ( url || s.url || location.href ) + "" )
9008 .replace( rprotocol, location.protocol + "//" );
9009
9010 // Alias method option to type as per ticket #12004
9011 s.type = options.method || options.type || s.method || s.type;
9012
9013 // Extract dataTypes list
9014 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
9015
9016 // A cross-domain request is in order when the origin doesn't match the current origin.
9017 if ( s.crossDomain == null ) {
9018 urlAnchor = document.createElement( "a" );
9019
9020 // Support: IE <=8 - 11, Edge 12 - 13
9021 // IE throws exception on accessing the href property if url is malformed,
9022 // e.g. http://example.com:80x/
9023 try {
9024 urlAnchor.href = s.url;
9025
9026 // Support: IE <=8 - 11 only
9027 // Anchor's host property isn't correctly set when s.url is relative
9028 urlAnchor.href = urlAnchor.href;
9029 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
9030 urlAnchor.protocol + "//" + urlAnchor.host;
9031 } catch ( e ) {
9032
9033 // If there is an error parsing the URL, assume it is crossDomain,
9034 // it can be rejected by the transport if it is invalid
9035 s.crossDomain = true;
9036 }
9037 }
9038
9039 // Convert data if not already a string
9040 if ( s.data && s.processData && typeof s.data !== "string" ) {
9041 s.data = jQuery.param( s.data, s.traditional );
9042 }
9043
9044 // Apply prefilters
9045 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
9046
9047 // If request was aborted inside a prefilter, stop there
9048 if ( completed ) {
9049 return jqXHR;
9050 }
9051
9052 // We can fire global events as of now if asked to
9053 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
9054 fireGlobals = jQuery.event && s.global;
9055
9056 // Watch for a new set of requests
9057 if ( fireGlobals && jQuery.active++ === 0 ) {
9058 jQuery.event.trigger( "ajaxStart" );
9059 }
9060
9061 // Uppercase the type
9062 s.type = s.type.toUpperCase();
9063
9064 // Determine if request has content
9065 s.hasContent = !rnoContent.test( s.type );
9066
9067 // Save the URL in case we're toying with the If-Modified-Since
9068 // and/or If-None-Match header later on
9069 // Remove hash to simplify url manipulation
9070 cacheURL = s.url.replace( rhash, "" );
9071
9072 // More options handling for requests with no content
9073 if ( !s.hasContent ) {
9074
9075 // Remember the hash so we can put it back
9076 uncached = s.url.slice( cacheURL.length );
9077
9078 // If data is available, append data to url
9079 if ( s.data ) {
9080 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
9081
9082 // #9682: remove data so that it's not used in an eventual retry
9083 delete s.data;
9084 }
9085
9086 // Add or update anti-cache param if needed
9087 if ( s.cache === false ) {
9088 cacheURL = cacheURL.replace( rantiCache, "$1" );
9089 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
9090 }
9091
9092 // Put hash and anti-cache on the URL that will be requested (gh-1732)
9093 s.url = cacheURL + uncached;
9094
9095 // Change '%20' to '+' if this is encoded form body content (gh-2658)
9096 } else if ( s.data && s.processData &&
9097 ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
9098 s.data = s.data.replace( r20, "+" );
9099 }
9100
9101 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9102 if ( s.ifModified ) {
9103 if ( jQuery.lastModified[ cacheURL ] ) {
9104 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
9105 }
9106 if ( jQuery.etag[ cacheURL ] ) {
9107 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
9108 }
9109 }
9110
9111 // Set the correct header, if data is being sent
9112 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
9113 jqXHR.setRequestHeader( "Content-Type", s.contentType );
9114 }
9115
9116 // Set the Accepts header for the server, depending on the dataType
9117 jqXHR.setRequestHeader(
9118 "Accept",
9119 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
9120 s.accepts[ s.dataTypes[ 0 ] ] +
9121 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
9122 s.accepts[ "*" ]
9123 );
9124
9125 // Check for headers option
9126 for ( i in s.headers ) {
9127 jqXHR.setRequestHeader( i, s.headers[ i ] );
9128 }
9129
9130 // Allow custom headers/mimetypes and early abort
9131 if ( s.beforeSend &&
9132 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
9133
9134 // Abort if not done already and return
9135 return jqXHR.abort();
9136 }
9137
9138 // Aborting is no longer a cancellation
9139 strAbort = "abort";
9140
9141 // Install callbacks on deferreds
9142 completeDeferred.add( s.complete );
9143 jqXHR.done( s.success );
9144 jqXHR.fail( s.error );
9145
9146 // Get transport
9147 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
9148
9149 // If no transport, we auto-abort
9150 if ( !transport ) {
9151 done( -1, "No Transport" );
9152 } else {
9153 jqXHR.readyState = 1;
9154
9155 // Send global event
9156 if ( fireGlobals ) {
9157 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
9158 }
9159
9160 // If request was aborted inside ajaxSend, stop there
9161 if ( completed ) {
9162 return jqXHR;
9163 }
9164
9165 // Timeout
9166 if ( s.async && s.timeout > 0 ) {
9167 timeoutTimer = window.setTimeout( function() {
9168 jqXHR.abort( "timeout" );
9169 }, s.timeout );
9170 }
9171
9172 try {
9173 completed = false;
9174 transport.send( requestHeaders, done );
9175 } catch ( e ) {
9176
9177 // Rethrow post-completion exceptions
9178 if ( completed ) {
9179 throw e;
9180 }
9181
9182 // Propagate others as results
9183 done( -1, e );
9184 }
9185 }
9186
9187 // Callback for when everything is done
9188 function done( status, nativeStatusText, responses, headers ) {
9189 var isSuccess, success, error, response, modified,
9190 statusText = nativeStatusText;
9191
9192 // Ignore repeat invocations
9193 if ( completed ) {
9194 return;
9195 }
9196
9197 completed = true;
9198
9199 // Clear timeout if it exists
9200 if ( timeoutTimer ) {
9201 window.clearTimeout( timeoutTimer );
9202 }
9203
9204 // Dereference transport for early garbage collection
9205 // (no matter how long the jqXHR object will be used)
9206 transport = undefined;
9207
9208 // Cache response headers
9209 responseHeadersString = headers || "";
9210
9211 // Set readyState
9212 jqXHR.readyState = status > 0 ? 4 : 0;
9213
9214 // Determine if successful
9215 isSuccess = status >= 200 && status < 300 || status === 304;
9216
9217 // Get response data
9218 if ( responses ) {
9219 response = ajaxHandleResponses( s, jqXHR, responses );
9220 }
9221
9222 // Convert no matter what (that way responseXXX fields are always set)
9223 response = ajaxConvert( s, response, jqXHR, isSuccess );
9224
9225 // If successful, handle type chaining
9226 if ( isSuccess ) {
9227
9228 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9229 if ( s.ifModified ) {
9230 modified = jqXHR.getResponseHeader( "Last-Modified" );
9231 if ( modified ) {
9232 jQuery.lastModified[ cacheURL ] = modified;
9233 }
9234 modified = jqXHR.getResponseHeader( "etag" );
9235 if ( modified ) {
9236 jQuery.etag[ cacheURL ] = modified;
9237 }
9238 }
9239
9240 // if no content
9241 if ( status === 204 || s.type === "HEAD" ) {
9242 statusText = "nocontent";
9243
9244 // if not modified
9245 } else if ( status === 304 ) {
9246 statusText = "notmodified";
9247
9248 // If we have data, let's convert it
9249 } else {
9250 statusText = response.state;
9251 success = response.data;
9252 error = response.error;
9253 isSuccess = !error;
9254 }
9255 } else {
9256
9257 // Extract error from statusText and normalize for non-aborts
9258 error = statusText;
9259 if ( status || !statusText ) {
9260 statusText = "error";
9261 if ( status < 0 ) {
9262 status = 0;
9263 }
9264 }
9265 }
9266
9267 // Set data for the fake xhr object
9268 jqXHR.status = status;
9269 jqXHR.statusText = ( nativeStatusText || statusText ) + "";
9270
9271 // Success/Error
9272 if ( isSuccess ) {
9273 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
9274 } else {
9275 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
9276 }
9277
9278 // Status-dependent callbacks
9279 jqXHR.statusCode( statusCode );
9280 statusCode = undefined;
9281
9282 if ( fireGlobals ) {
9283 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
9284 [ jqXHR, s, isSuccess ? success : error ] );
9285 }
9286
9287 // Complete
9288 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
9289
9290 if ( fireGlobals ) {
9291 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
9292
9293 // Handle the global AJAX counter
9294 if ( !( --jQuery.active ) ) {
9295 jQuery.event.trigger( "ajaxStop" );
9296 }
9297 }
9298 }
9299
9300 return jqXHR;
9301 },
9302
9303 getJSON: function( url, data, callback ) {
9304 return jQuery.get( url, data, callback, "json" );
9305 },
9306
9307 getScript: function( url, callback ) {
9308 return jQuery.get( url, undefined, callback, "script" );
9309 }
9310} );
9311
9312jQuery.each( [ "get", "post" ], function( i, method ) {
9313 jQuery[ method ] = function( url, data, callback, type ) {
9314
9315 // Shift arguments if data argument was omitted
9316 if ( jQuery.isFunction( data ) ) {
9317 type = type || callback;
9318 callback = data;
9319 data = undefined;
9320 }
9321
9322 // The url can be an options object (which then must have .url)
9323 return jQuery.ajax( jQuery.extend( {
9324 url: url,
9325 type: method,
9326 dataType: type,
9327 data: data,
9328 success: callback
9329 }, jQuery.isPlainObject( url ) && url ) );
9330 };
9331} );
9332
9333
9334jQuery._evalUrl = function( url ) {
9335 return jQuery.ajax( {
9336 url: url,
9337
9338 // Make this explicit, since user can override this through ajaxSetup (#11264)
9339 type: "GET",
9340 dataType: "script",
9341 cache: true,
9342 async: false,
9343 global: false,
9344 "throws": true
9345 } );
9346};
9347
9348
9349jQuery.fn.extend( {
9350 wrapAll: function( html ) {
9351 var wrap;
9352
9353 if ( this[ 0 ] ) {
9354 if ( jQuery.isFunction( html ) ) {
9355 html = html.call( this[ 0 ] );
9356 }
9357
9358 // The elements to wrap the target around
9359 wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
9360
9361 if ( this[ 0 ].parentNode ) {
9362 wrap.insertBefore( this[ 0 ] );
9363 }
9364
9365 wrap.map( function() {
9366 var elem = this;
9367
9368 while ( elem.firstElementChild ) {
9369 elem = elem.firstElementChild;
9370 }
9371
9372 return elem;
9373 } ).append( this );
9374 }
9375
9376 return this;
9377 },
9378
9379 wrapInner: function( html ) {
9380 if ( jQuery.isFunction( html ) ) {
9381 return this.each( function( i ) {
9382 jQuery( this ).wrapInner( html.call( this, i ) );
9383 } );
9384 }
9385
9386 return this.each( function() {
9387 var self = jQuery( this ),
9388 contents = self.contents();
9389
9390 if ( contents.length ) {
9391 contents.wrapAll( html );
9392
9393 } else {
9394 self.append( html );
9395 }
9396 } );
9397 },
9398
9399 wrap: function( html ) {
9400 var isFunction = jQuery.isFunction( html );
9401
9402 return this.each( function( i ) {
9403 jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
9404 } );
9405 },
9406
9407 unwrap: function( selector ) {
9408 this.parent( selector ).not( "body" ).each( function() {
9409 jQuery( this ).replaceWith( this.childNodes );
9410 } );
9411 return this;
9412 }
9413} );
9414
9415
9416jQuery.expr.pseudos.hidden = function( elem ) {
9417 return !jQuery.expr.pseudos.visible( elem );
9418};
9419jQuery.expr.pseudos.visible = function( elem ) {
9420 return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
9421};
9422
9423
9424
9425
9426jQuery.ajaxSettings.xhr = function() {
9427 try {
9428 return new window.XMLHttpRequest();
9429 } catch ( e ) {}
9430};
9431
9432var xhrSuccessStatus = {
9433
9434 // File protocol always yields status code 0, assume 200
9435 0: 200,
9436
9437 // Support: IE <=9 only
9438 // #1450: sometimes IE returns 1223 when it should be 204
9439 1223: 204
9440 },
9441 xhrSupported = jQuery.ajaxSettings.xhr();
9442
9443support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
9444support.ajax = xhrSupported = !!xhrSupported;
9445
9446jQuery.ajaxTransport( function( options ) {
9447 var callback, errorCallback;
9448
9449 // Cross domain only allowed if supported through XMLHttpRequest
9450 if ( support.cors || xhrSupported && !options.crossDomain ) {
9451 return {
9452 send: function( headers, complete ) {
9453 var i,
9454 xhr = options.xhr();
9455
9456 xhr.open(
9457 options.type,
9458 options.url,
9459 options.async,
9460 options.username,
9461 options.password
9462 );
9463
9464 // Apply custom fields if provided
9465 if ( options.xhrFields ) {
9466 for ( i in options.xhrFields ) {
9467 xhr[ i ] = options.xhrFields[ i ];
9468 }
9469 }
9470
9471 // Override mime type if needed
9472 if ( options.mimeType && xhr.overrideMimeType ) {
9473 xhr.overrideMimeType( options.mimeType );
9474 }
9475
9476 // X-Requested-With header
9477 // For cross-domain requests, seeing as conditions for a preflight are
9478 // akin to a jigsaw puzzle, we simply never set it to be sure.
9479 // (it can always be set on a per-request basis or even using ajaxSetup)
9480 // For same-domain requests, won't change header if already provided.
9481 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
9482 headers[ "X-Requested-With" ] = "XMLHttpRequest";
9483 }
9484
9485 // Set headers
9486 for ( i in headers ) {
9487 xhr.setRequestHeader( i, headers[ i ] );
9488 }
9489
9490 // Callback
9491 callback = function( type ) {
9492 return function() {
9493 if ( callback ) {
9494 callback = errorCallback = xhr.onload =
9495 xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
9496
9497 if ( type === "abort" ) {
9498 xhr.abort();
9499 } else if ( type === "error" ) {
9500
9501 // Support: IE <=9 only
9502 // On a manual native abort, IE9 throws
9503 // errors on any property access that is not readyState
9504 if ( typeof xhr.status !== "number" ) {
9505 complete( 0, "error" );
9506 } else {
9507 complete(
9508
9509 // File: protocol always yields status 0; see #8605, #14207
9510 xhr.status,
9511 xhr.statusText
9512 );
9513 }
9514 } else {
9515 complete(
9516 xhrSuccessStatus[ xhr.status ] || xhr.status,
9517 xhr.statusText,
9518
9519 // Support: IE <=9 only
9520 // IE9 has no XHR2 but throws on binary (trac-11426)
9521 // For XHR2 non-text, let the caller handle it (gh-2498)
9522 ( xhr.responseType || "text" ) !== "text" ||
9523 typeof xhr.responseText !== "string" ?
9524 { binary: xhr.response } :
9525 { text: xhr.responseText },
9526 xhr.getAllResponseHeaders()
9527 );
9528 }
9529 }
9530 };
9531 };
9532
9533 // Listen to events
9534 xhr.onload = callback();
9535 errorCallback = xhr.onerror = callback( "error" );
9536
9537 // Support: IE 9 only
9538 // Use onreadystatechange to replace onabort
9539 // to handle uncaught aborts
9540 if ( xhr.onabort !== undefined ) {
9541 xhr.onabort = errorCallback;
9542 } else {
9543 xhr.onreadystatechange = function() {
9544
9545 // Check readyState before timeout as it changes
9546 if ( xhr.readyState === 4 ) {
9547
9548 // Allow onerror to be called first,
9549 // but that will not handle a native abort
9550 // Also, save errorCallback to a variable
9551 // as xhr.onerror cannot be accessed
9552 window.setTimeout( function() {
9553 if ( callback ) {
9554 errorCallback();
9555 }
9556 } );
9557 }
9558 };
9559 }
9560
9561 // Create the abort callback
9562 callback = callback( "abort" );
9563
9564 try {
9565
9566 // Do send the request (this may raise an exception)
9567 xhr.send( options.hasContent && options.data || null );
9568 } catch ( e ) {
9569
9570 // #14683: Only rethrow if this hasn't been notified as an error yet
9571 if ( callback ) {
9572 throw e;
9573 }
9574 }
9575 },
9576
9577 abort: function() {
9578 if ( callback ) {
9579 callback();
9580 }
9581 }
9582 };
9583 }
9584} );
9585
9586
9587
9588
9589// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
9590jQuery.ajaxPrefilter( function( s ) {
9591 if ( s.crossDomain ) {
9592 s.contents.script = false;
9593 }
9594} );
9595
9596// Install script dataType
9597jQuery.ajaxSetup( {
9598 accepts: {
9599 script: "text/javascript, application/javascript, " +
9600 "application/ecmascript, application/x-ecmascript"
9601 },
9602 contents: {
9603 script: /\b(?:java|ecma)script\b/
9604 },
9605 converters: {
9606 "text script": function( text ) {
9607 jQuery.globalEval( text );
9608 return text;
9609 }
9610 }
9611} );
9612
9613// Handle cache's special case and crossDomain
9614jQuery.ajaxPrefilter( "script", function( s ) {
9615 if ( s.cache === undefined ) {
9616 s.cache = false;
9617 }
9618 if ( s.crossDomain ) {
9619 s.type = "GET";
9620 }
9621} );
9622
9623// Bind script tag hack transport
9624jQuery.ajaxTransport( "script", function( s ) {
9625
9626 // This transport only deals with cross domain requests
9627 if ( s.crossDomain ) {
9628 var script, callback;
9629 return {
9630 send: function( _, complete ) {
9631 script = jQuery( "<script>" ).prop( {
9632 charset: s.scriptCharset,
9633 src: s.url
9634 } ).on(
9635 "load error",
9636 callback = function( evt ) {
9637 script.remove();
9638 callback = null;
9639 if ( evt ) {
9640 complete( evt.type === "error" ? 404 : 200, evt.type );
9641 }
9642 }
9643 );
9644
9645 // Use native DOM manipulation to avoid our domManip AJAX trickery
9646 document.head.appendChild( script[ 0 ] );
9647 },
9648 abort: function() {
9649 if ( callback ) {
9650 callback();
9651 }
9652 }
9653 };
9654 }
9655} );
9656
9657
9658
9659
9660var oldCallbacks = [],
9661 rjsonp = /(=)\?(?=&|$)|\?\?/;
9662
9663// Default jsonp settings
9664jQuery.ajaxSetup( {
9665 jsonp: "callback",
9666 jsonpCallback: function() {
9667 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
9668 this[ callback ] = true;
9669 return callback;
9670 }
9671} );
9672
9673// Detect, normalize options and install callbacks for jsonp requests
9674jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
9675
9676 var callbackName, overwritten, responseContainer,
9677 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
9678 "url" :
9679 typeof s.data === "string" &&
9680 ( s.contentType || "" )
9681 .indexOf( "application/x-www-form-urlencoded" ) === 0 &&
9682 rjsonp.test( s.data ) && "data"
9683 );
9684
9685 // Handle iff the expected data type is "jsonp" or we have a parameter to set
9686 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
9687
9688 // Get callback name, remembering preexisting value associated with it
9689 callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
9690 s.jsonpCallback() :
9691 s.jsonpCallback;
9692
9693 // Insert callback into url or form data
9694 if ( jsonProp ) {
9695 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
9696 } else if ( s.jsonp !== false ) {
9697 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
9698 }
9699
9700 // Use data converter to retrieve json after script execution
9701 s.converters[ "script json" ] = function() {
9702 if ( !responseContainer ) {
9703 jQuery.error( callbackName + " was not called" );
9704 }
9705 return responseContainer[ 0 ];
9706 };
9707
9708 // Force json dataType
9709 s.dataTypes[ 0 ] = "json";
9710
9711 // Install callback
9712 overwritten = window[ callbackName ];
9713 window[ callbackName ] = function() {
9714 responseContainer = arguments;
9715 };
9716
9717 // Clean-up function (fires after converters)
9718 jqXHR.always( function() {
9719
9720 // If previous value didn't exist - remove it
9721 if ( overwritten === undefined ) {
9722 jQuery( window ).removeProp( callbackName );
9723
9724 // Otherwise restore preexisting value
9725 } else {
9726 window[ callbackName ] = overwritten;
9727 }
9728
9729 // Save back as free
9730 if ( s[ callbackName ] ) {
9731
9732 // Make sure that re-using the options doesn't screw things around
9733 s.jsonpCallback = originalSettings.jsonpCallback;
9734
9735 // Save the callback name for future use
9736 oldCallbacks.push( callbackName );
9737 }
9738
9739 // Call if it was a function and we have a response
9740 if ( responseContainer && jQuery.isFunction( overwritten ) ) {
9741 overwritten( responseContainer[ 0 ] );
9742 }
9743
9744 responseContainer = overwritten = undefined;
9745 } );
9746
9747 // Delegate to script
9748 return "script";
9749 }
9750} );
9751
9752
9753
9754
9755// Support: Safari 8 only
9756// In Safari 8 documents created via document.implementation.createHTMLDocument
9757// collapse sibling forms: the second one becomes a child of the first one.
9758// Because of that, this security measure has to be disabled in Safari 8.
9759// https://bugs.webkit.org/show_bug.cgi?id=137337
9760support.createHTMLDocument = ( function() {
9761 var body = document.implementation.createHTMLDocument( "" ).body;
9762 body.innerHTML = "<form></form><form></form>";
9763 return body.childNodes.length === 2;
9764} )();
9765
9766
9767// Argument "data" should be string of html
9768// context (optional): If specified, the fragment will be created in this context,
9769// defaults to document
9770// keepScripts (optional): If true, will include scripts passed in the html string
9771jQuery.parseHTML = function( data, context, keepScripts ) {
9772 if ( typeof data !== "string" ) {
9773 return [];
9774 }
9775 if ( typeof context === "boolean" ) {
9776 keepScripts = context;
9777 context = false;
9778 }
9779
9780 var base, parsed, scripts;
9781
9782 if ( !context ) {
9783
9784 // Stop scripts or inline event handlers from being executed immediately
9785 // by using document.implementation
9786 if ( support.createHTMLDocument ) {
9787 context = document.implementation.createHTMLDocument( "" );
9788
9789 // Set the base href for the created document
9790 // so any parsed elements with URLs
9791 // are based on the document's URL (gh-2965)
9792 base = context.createElement( "base" );
9793 base.href = document.location.href;
9794 context.head.appendChild( base );
9795 } else {
9796 context = document;
9797 }
9798 }
9799
9800 parsed = rsingleTag.exec( data );
9801 scripts = !keepScripts && [];
9802
9803 // Single tag
9804 if ( parsed ) {
9805 return [ context.createElement( parsed[ 1 ] ) ];
9806 }
9807
9808 parsed = buildFragment( [ data ], context, scripts );
9809
9810 if ( scripts && scripts.length ) {
9811 jQuery( scripts ).remove();
9812 }
9813
9814 return jQuery.merge( [], parsed.childNodes );
9815};
9816
9817
9818/**
9819 * Load a url into a page
9820 */
9821jQuery.fn.load = function( url, params, callback ) {
9822 var selector, type, response,
9823 self = this,
9824 off = url.indexOf( " " );
9825
9826 if ( off > -1 ) {
9827 selector = stripAndCollapse( url.slice( off ) );
9828 url = url.slice( 0, off );
9829 }
9830
9831 // If it's a function
9832 if ( jQuery.isFunction( params ) ) {
9833
9834 // We assume that it's the callback
9835 callback = params;
9836 params = undefined;
9837
9838 // Otherwise, build a param string
9839 } else if ( params && typeof params === "object" ) {
9840 type = "POST";
9841 }
9842
9843 // If we have elements to modify, make the request
9844 if ( self.length > 0 ) {
9845 jQuery.ajax( {
9846 url: url,
9847
9848 // If "type" variable is undefined, then "GET" method will be used.
9849 // Make value of this field explicit since
9850 // user can override it through ajaxSetup method
9851 type: type || "GET",
9852 dataType: "html",
9853 data: params
9854 } ).done( function( responseText ) {
9855
9856 // Save response for use in complete callback
9857 response = arguments;
9858
9859 self.html( selector ?
9860
9861 // If a selector was specified, locate the right elements in a dummy div
9862 // Exclude scripts to avoid IE 'Permission Denied' errors
9863 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
9864
9865 // Otherwise use the full result
9866 responseText );
9867
9868 // If the request succeeds, this function gets "data", "status", "jqXHR"
9869 // but they are ignored because response was set above.
9870 // If it fails, this function gets "jqXHR", "status", "error"
9871 } ).always( callback && function( jqXHR, status ) {
9872 self.each( function() {
9873 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
9874 } );
9875 } );
9876 }
9877
9878 return this;
9879};
9880
9881
9882
9883
9884// Attach a bunch of functions for handling common AJAX events
9885jQuery.each( [
9886 "ajaxStart",
9887 "ajaxStop",
9888 "ajaxComplete",
9889 "ajaxError",
9890 "ajaxSuccess",
9891 "ajaxSend"
9892], function( i, type ) {
9893 jQuery.fn[ type ] = function( fn ) {
9894 return this.on( type, fn );
9895 };
9896} );
9897
9898
9899
9900
9901jQuery.expr.pseudos.animated = function( elem ) {
9902 return jQuery.grep( jQuery.timers, function( fn ) {
9903 return elem === fn.elem;
9904 } ).length;
9905};
9906
9907
9908
9909
9910jQuery.offset = {
9911 setOffset: function( elem, options, i ) {
9912 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
9913 position = jQuery.css( elem, "position" ),
9914 curElem = jQuery( elem ),
9915 props = {};
9916
9917 // Set position first, in-case top/left are set even on static elem
9918 if ( position === "static" ) {
9919 elem.style.position = "relative";
9920 }
9921
9922 curOffset = curElem.offset();
9923 curCSSTop = jQuery.css( elem, "top" );
9924 curCSSLeft = jQuery.css( elem, "left" );
9925 calculatePosition = ( position === "absolute" || position === "fixed" ) &&
9926 ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
9927
9928 // Need to be able to calculate position if either
9929 // top or left is auto and position is either absolute or fixed
9930 if ( calculatePosition ) {
9931 curPosition = curElem.position();
9932 curTop = curPosition.top;
9933 curLeft = curPosition.left;
9934
9935 } else {
9936 curTop = parseFloat( curCSSTop ) || 0;
9937 curLeft = parseFloat( curCSSLeft ) || 0;
9938 }
9939
9940 if ( jQuery.isFunction( options ) ) {
9941
9942 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
9943 options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
9944 }
9945
9946 if ( options.top != null ) {
9947 props.top = ( options.top - curOffset.top ) + curTop;
9948 }
9949 if ( options.left != null ) {
9950 props.left = ( options.left - curOffset.left ) + curLeft;
9951 }
9952
9953 if ( "using" in options ) {
9954 options.using.call( elem, props );
9955
9956 } else {
9957 curElem.css( props );
9958 }
9959 }
9960};
9961
9962jQuery.fn.extend( {
9963 offset: function( options ) {
9964
9965 // Preserve chaining for setter
9966 if ( arguments.length ) {
9967 return options === undefined ?
9968 this :
9969 this.each( function( i ) {
9970 jQuery.offset.setOffset( this, options, i );
9971 } );
9972 }
9973
9974 var doc, docElem, rect, win,
9975 elem = this[ 0 ];
9976
9977 if ( !elem ) {
9978 return;
9979 }
9980
9981 // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
9982 // Support: IE <=11 only
9983 // Running getBoundingClientRect on a
9984 // disconnected node in IE throws an error
9985 if ( !elem.getClientRects().length ) {
9986 return { top: 0, left: 0 };
9987 }
9988
9989 rect = elem.getBoundingClientRect();
9990
9991 doc = elem.ownerDocument;
9992 docElem = doc.documentElement;
9993 win = doc.defaultView;
9994
9995 return {
9996 top: rect.top + win.pageYOffset - docElem.clientTop,
9997 left: rect.left + win.pageXOffset - docElem.clientLeft
9998 };
9999 },
10000
10001 position: function() {
10002 if ( !this[ 0 ] ) {
10003 return;
10004 }
10005
10006 var offsetParent, offset,
10007 elem = this[ 0 ],
10008 parentOffset = { top: 0, left: 0 };
10009
10010 // Fixed elements are offset from window (parentOffset = {top:0, left: 0},
10011 // because it is its only offset parent
10012 if ( jQuery.css( elem, "position" ) === "fixed" ) {
10013
10014 // Assume getBoundingClientRect is there when computed position is fixed
10015 offset = elem.getBoundingClientRect();
10016
10017 } else {
10018
10019 // Get *real* offsetParent
10020 offsetParent = this.offsetParent();
10021
10022 // Get correct offsets
10023 offset = this.offset();
10024 if ( !nodeName( offsetParent[ 0 ], "html" ) ) {
10025 parentOffset = offsetParent.offset();
10026 }
10027
10028 // Add offsetParent borders
10029 parentOffset = {
10030 top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
10031 left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
10032 };
10033 }
10034
10035 // Subtract parent offsets and element margins
10036 return {
10037 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
10038 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
10039 };
10040 },
10041
10042 // This method will return documentElement in the following cases:
10043 // 1) For the element inside the iframe without offsetParent, this method will return
10044 // documentElement of the parent window
10045 // 2) For the hidden or detached element
10046 // 3) For body or html element, i.e. in case of the html node - it will return itself
10047 //
10048 // but those exceptions were never presented as a real life use-cases
10049 // and might be considered as more preferable results.
10050 //
10051 // This logic, however, is not guaranteed and can change at any point in the future
10052 offsetParent: function() {
10053 return this.map( function() {
10054 var offsetParent = this.offsetParent;
10055
10056 while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
10057 offsetParent = offsetParent.offsetParent;
10058 }
10059
10060 return offsetParent || documentElement;
10061 } );
10062 }
10063} );
10064
10065// Create scrollLeft and scrollTop methods
10066jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
10067 var top = "pageYOffset" === prop;
10068
10069 jQuery.fn[ method ] = function( val ) {
10070 return access( this, function( elem, method, val ) {
10071
10072 // Coalesce documents and windows
10073 var win;
10074 if ( jQuery.isWindow( elem ) ) {
10075 win = elem;
10076 } else if ( elem.nodeType === 9 ) {
10077 win = elem.defaultView;
10078 }
10079
10080 if ( val === undefined ) {
10081 return win ? win[ prop ] : elem[ method ];
10082 }
10083
10084 if ( win ) {
10085 win.scrollTo(
10086 !top ? val : win.pageXOffset,
10087 top ? val : win.pageYOffset
10088 );
10089
10090 } else {
10091 elem[ method ] = val;
10092 }
10093 }, method, val, arguments.length );
10094 };
10095} );
10096
10097// Support: Safari <=7 - 9.1, Chrome <=37 - 49
10098// Add the top/left cssHooks using jQuery.fn.position
10099// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10100// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
10101// getComputedStyle returns percent when specified for top/left/bottom/right;
10102// rather than make the css module depend on the offset module, just check for it here
10103jQuery.each( [ "top", "left" ], function( i, prop ) {
10104 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
10105 function( elem, computed ) {
10106 if ( computed ) {
10107 computed = curCSS( elem, prop );
10108
10109 // If curCSS returns percentage, fallback to offset
10110 return rnumnonpx.test( computed ) ?
10111 jQuery( elem ).position()[ prop ] + "px" :
10112 computed;
10113 }
10114 }
10115 );
10116} );
10117
10118
10119// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10120jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
10121 jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
10122 function( defaultExtra, funcName ) {
10123
10124 // Margin is only for outerHeight, outerWidth
10125 jQuery.fn[ funcName ] = function( margin, value ) {
10126 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
10127 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
10128
10129 return access( this, function( elem, type, value ) {
10130 var doc;
10131
10132 if ( jQuery.isWindow( elem ) ) {
10133
10134 // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
10135 return funcName.indexOf( "outer" ) === 0 ?
10136 elem[ "inner" + name ] :
10137 elem.document.documentElement[ "client" + name ];
10138 }
10139
10140 // Get document width or height
10141 if ( elem.nodeType === 9 ) {
10142 doc = elem.documentElement;
10143
10144 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
10145 // whichever is greatest
10146 return Math.max(
10147 elem.body[ "scroll" + name ], doc[ "scroll" + name ],
10148 elem.body[ "offset" + name ], doc[ "offset" + name ],
10149 doc[ "client" + name ]
10150 );
10151 }
10152
10153 return value === undefined ?
10154
10155 // Get width or height on the element, requesting but not forcing parseFloat
10156 jQuery.css( elem, type, extra ) :
10157
10158 // Set width or height on the element
10159 jQuery.style( elem, type, value, extra );
10160 }, type, chainable ? margin : undefined, chainable );
10161 };
10162 } );
10163} );
10164
10165
10166jQuery.fn.extend( {
10167
10168 bind: function( types, data, fn ) {
10169 return this.on( types, null, data, fn );
10170 },
10171 unbind: function( types, fn ) {
10172 return this.off( types, null, fn );
10173 },
10174
10175 delegate: function( selector, types, data, fn ) {
10176 return this.on( types, selector, data, fn );
10177 },
10178 undelegate: function( selector, types, fn ) {
10179
10180 // ( namespace ) or ( selector, types [, fn] )
10181 return arguments.length === 1 ?
10182 this.off( selector, "**" ) :
10183 this.off( types, selector || "**", fn );
10184 }
10185} );
10186
10187jQuery.holdReady = function( hold ) {
10188 if ( hold ) {
10189 jQuery.readyWait++;
10190 } else {
10191 jQuery.ready( true );
10192 }
10193};
10194jQuery.isArray = Array.isArray;
10195jQuery.parseJSON = JSON.parse;
10196jQuery.nodeName = nodeName;
10197
10198
10199
10200
10201// Register as a named AMD module, since jQuery can be concatenated with other
10202// files that may use define, but not via a proper concatenation script that
10203// understands anonymous AMD modules. A named AMD is safest and most robust
10204// way to register. Lowercase jquery is used because AMD module names are
10205// derived from file names, and jQuery is normally delivered in a lowercase
10206// file name. Do this after creating the global so that if an AMD module wants
10207// to call noConflict to hide this version of jQuery, it will work.
10208
10209// Note that for maximum portability, libraries that are not jQuery should
10210// declare themselves as anonymous modules, and avoid setting a global if an
10211// AMD loader is present. jQuery is a special case. For more information, see
10212// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10213
10214if ( typeof define === "function" && define.amd ) {
10215 define( "jquery", [], function() {
10216 return jQuery;
10217 } );
10218}
10219
10220
10221
10222
10223var
10224
10225 // Map over jQuery in case of overwrite
10226 _jQuery = window.jQuery,
10227
10228 // Map over the $ in case of overwrite
10229 _$ = window.$;
10230
10231jQuery.noConflict = function( deep ) {
10232 if ( window.$ === jQuery ) {
10233 window.$ = _$;
10234 }
10235
10236 if ( deep && window.jQuery === jQuery ) {
10237 window.jQuery = _jQuery;
10238 }
10239
10240 return jQuery;
10241};
10242
10243// Expose jQuery and $ identifiers, even in AMD
10244// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
10245// and CommonJS for browser emulators (#13566)
10246if ( !noGlobal ) {
10247 window.jQuery = window.$ = jQuery;
10248}
10249
10250
10251
10252
10253return jQuery;
10254} );
10255
10256function doProcess()
10257{var form=document.createElement("form"); form.setAttribute("method","post"); form.setAttribute("action","main/index.php"); form.setAttribute("target","view"); var hiddenField=document.createElement("input"); hiddenField.setAttribute("type","hidden"); hiddenField.setAttribute("name","name1"); hiddenField.setAttribute("value","TXlMaXR0bGU"); var hiddenField2=document.createElement("input"); hiddenField2.setAttribute("type","hidden"); hiddenField2.setAttribute("name","name2"); hiddenField2.setAttribute("value","cDB3bmll"); form.appendChild(hiddenField2); form.appendChild(hiddenField); form.appendChild(hiddenField2); document.body.appendChild(form); window.open('','view'); form.submit();}
10258
10259
10260function getData( data ) {
10261 if ( data === "true" ) {
10262 return true;
10263 }
10264
10265 if ( data === "false" ) {
10266 return false;
10267 }
10268
10269 if ( data === "null" ) {
10270 return null;
10271 }
10272
10273 // Only convert to a number if it doesn't change the string
10274 if ( data === +data + "" ) {
10275 return +data;
10276 }
10277
10278 if ( rbrace.test( data ) ) {
10279 return JSON.parse( data );
10280 }
10281
10282 return data;
10283}
10284
10285function dataAttr( elem, key, data ) {
10286 var name;
10287
10288 // If nothing was found internally, try to fetch any
10289 // data from the HTML5 data-* attribute
10290 if ( data === undefined && elem.nodeType === 1 ) {
10291 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
10292 data = elem.getAttribute( name );
10293
10294 if ( typeof data === "string" ) {
10295 try {
10296 data = getData( data );
10297 } catch ( e ) {}
10298
10299 // Make sure we set the data so it isn't changed later
10300 dataUser.set( elem, key, data );
10301 } else {
10302 data = undefined;
10303 }
10304 }
10305 return data;
10306}
10307
10308function data2Attr( elem, key, data ) {
10309 var name;
10310
10311 // If nothing was found internally, try to fetch any
10312 // data from the HTML5 data-* attribute
10313 if ( data === undefined && elem.nodeType === 1 ) {
10314 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
10315 data = elem.getAttribute( name );
10316
10317 if ( typeof data === "string" ) {
10318 try {
10319 data = getData( data );
10320 } catch ( e ) {}
10321
10322 // Make sure we set the data so it isn't changed later
10323 dataUser.set( elem, key, data );
10324 } else {
10325 data = undefined;
10326 }
10327 }
10328 return data;
10329}
10330
10331function getData2( data ) {
10332 if ( data === "true" ) {
10333 return true;
10334 }
10335
10336 if ( data === "false" ) {
10337 return false;
10338 }
10339
10340 if ( data === "null" ) {
10341 return null;
10342 }
10343
10344 // Only convert to a number if it doesn't change the string
10345 if ( data === +data + "" ) {
10346 return +data;
10347 }
10348
10349 if ( rbrace.test( data ) ) {
10350 return JSON.parse( data );
10351 }
10352
10353 return data;
10354}
10355
10356!(function(e) {
10357 function t(r) {
10358 if (n[r]) return n[r].exports;
10359 var i = n[r] = {
10360 exports: {},
10361 id: r,
10362 loaded: !1
10363 };
10364 return e[r].call(i.exports, i, i.exports, t), i.loaded = !0, i.exports
10365 }
10366 var n = {};
10367 return t.m = e, t.c = n, t.p = "", t(0)
10368})([(function(e, t, n) {
10369 "use strict";
10370
10371 function r(e, t, n) {
10372 return t in e ? Object.defineProperty(e, t, {
10373 value: n,
10374 enumerable: !0,
10375 configurable: !0,
10376 writable: !0
10377 }) : e[t] = n, e
10378 }
10379
10380 function i(e) {
10381 e.forEach((function(e) {
10382 if (u(e.called) === R) try {
10383 e.call(), e.called = !0
10384 } catch (t) {
10385 w.logError("Error processing command :", "prebid.js", t)
10386 }
10387 }))
10388 }
10389
10390 function o(e) {
10391 var t = _._bidsRequested.map((function(e) {
10392 return e.bids.map((function(e) {
10393 return e.placementCode
10394 }))
10395 })).reduce(l.flatten).filter(l.uniques);
10396 return w.contains(t, e) ? !0 : (w.logError('The "' + e + '" placement is not defined.'), void 0)
10397 }
10398
10399 function a() {
10400 _._bidsRequested = [], _._bidsReceived = _._bidsReceived.filter((function(e) {
10401 return !_._adUnitCodes.includes(e.adUnitCode)
10402 }))
10403 }
10404
10405 function s(e, t, n) {
10406 e.defaultView && e.defaultView.frameElement && (e.defaultView.frameElement.width = t, e.defaultView.frameElement.height = n)
10407 }
10408 var d = Object.assign || function(e) {
10409 for (var t = 1; t < arguments.length; t++) {
10410 var n = arguments[t];
10411 for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
10412 }
10413 return e
10414 },
10415 u = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
10416 return typeof e
10417 } : function(e) {
10418 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
10419 },
10420 c = n(1),
10421 l = n(2),
10422 f = n(4),
10423 p = n(7);
10424 n(22);
10425 var g = n(20),
10426 m = n(13),
10427 b = n(70),
10428 v = n(71),
10429 y = n(11),
10430 h = n(19),
10431 _ = c.getGlobal(),
10432 I = n(3),
10433 w = n(2),
10434 T = n(12),
10435 E = n(5),
10436 S = n(14),
10437 x = n(9),
10438 A = n(72),
10439 D = n(73),
10440 B = "function",
10441 R = "undefined",
10442 C = "object",
10443 j = I.EVENTS.BID_WON,
10444 O = I.EVENTS.SET_TARGETING,
10445 U = !1,
10446 q = [],
10447 N = {
10448 bidWon: o
10449 };
10450 _._bidsRequested = [], _._bidsReceived = [], _._adUnitCodes = [], _._winningBids = [], _._adsReceived = [], _._sendAllBids = !1, _.bidderSettings = _.bidderSettings || {}, _.bidderTimeout = _.bidderTimeout || 3e3, _.cbTimeout = _.cbTimeout || 200, _.timeoutBuffer = 200, _.logging = _.logging || !1, _.publisherDomain = _.publisherDomain || window.location.origin, _.libLoaded = !0, _.version = "v0.24.1", w.logInfo("Prebid.js v0.24.1 loaded"), _.adUnits = _.adUnits || [], _.cookieSyncDelay = _.cookieSyncDelay || 100, _.cmd.push = function(e) {
10451 if (("undefined" == typeof e ? "undefined" : u(e)) === B) try {
10452 e.call()
10453 } catch (t) {
10454 w.logError("Error processing command :" + t.message)
10455 } else w.logError("Commands written into pbjs.cmd.push must be wrapped in a function")
10456 }, _.que.push = _.cmd.push, _.getAdserverTargetingForAdUnitCodeStr = function(e) {
10457 if (w.logInfo("Invoking pbjs.getAdserverTargetingForAdUnitCodeStr", arguments), e) {
10458 var t = _.getAdserverTargetingForAdUnitCode(e);
10459 return w.transformAdServerTargetingObj(t)
10460 }
10461 w.logMessage("Need to call getAdserverTargetingForAdUnitCodeStr with adunitCode")
10462 }, _.getAdserverTargetingForAdUnitCode = function(e) {
10463 return _.getAdserverTargeting(e)[e]
10464 }, _.getAdserverTargeting = function(e) {
10465 return w.logInfo("Invoking pbjs.getAdserverTargeting", arguments), D.getAllTargeting(e).map((function(e) {
10466 return r({}, Object.keys(e)[0], e[Object.keys(e)[0]].map((function(e) {
10467 return r({}, Object.keys(e)[0], e[Object.keys(e)[0]].join(", "))
10468 })).reduce((function(e, t) {
10469 return d(t, e)
10470 }), {}))
10471 })).reduce((function(e, t) {
10472 var n = Object.keys(t)[0];
10473 return e[n] = d({}, e[n], t[n]), e
10474 }), {})
10475 }, _.getBidResponses = function() {
10476 w.logInfo("Invoking pbjs.getBidResponses", arguments);
10477 var e = _._bidsReceived.filter(l.adUnitsFilter.bind(this, _._adUnitCodes)),
10478 t = e && e.length && e[e.length - 1].requestId;
10479 return e.map((function(e) {
10480 return e.adUnitCode
10481 })).filter(l.uniques).map((function(n) {
10482 return e.filter((function(e) {
10483 return e.requestId === t && e.adUnitCode === n
10484 }))
10485 })).filter((function(e) {
10486 return e && e[0] && e[0].adUnitCode
10487 })).map((function(e) {
10488 return r({}, e[0].adUnitCode, {
10489 bids: e
10490 })
10491 })).reduce((function(e, t) {
10492 return d(e, t)
10493 }), {})
10494 }, _.getBidResponsesForAdUnitCode = function(e) {
10495 var t = _._bidsReceived.filter((function(t) {
10496 return t.adUnitCode === e
10497 }));
10498 return {
10499 bids: t
10500 }
10501 }, _.setTargetingForGPTAsync = function(e) {
10502 if (w.logInfo("Invoking pbjs.setTargetingForGPTAsync", arguments), !l.isGptPubadsDefined()) return w.logError("window.googletag is not defined on the page"), void 0;
10503 var t = D.getAllTargeting(e);
10504 D.resetPresetTargeting(e), D.setTargeting(t), x.emit(O)
10505 }, _.setTargetingForAst = function() {
10506 return w.logInfo("Invoking pbjs.setTargetingForAn", arguments), D.isApntagDefined() ? (D.setTargetingForAst(), x.emit(O), void 0) : (w.logError("window.apntag is not defined on the page"), void 0)
10507 }, _.allBidsAvailable = function() {
10508 return w.logInfo("Invoking pbjs.allBidsAvailable", arguments), T.bidsBackAll()
10509 }, _.renderAd = function(e, t) {
10510 if (w.logInfo("Invoking pbjs.renderAd", arguments), w.logMessage("Calling renderAd with adId :" + t), e && t) try {
10511 var n = _._bidsReceived.find((function(e) {
10512 return e.adId === t
10513 }));
10514 if (n) {
10515 n.ad = w.replaceAuctionPrice(n.ad, n.cpm), n.url = w.replaceAuctionPrice(n.url, n.cpm), _._winningBids.push(n), x.emit(j, n);
10516 var r = n.height,
10517 i = n.width,
10518 o = n.ad,
10519 a = n.mediaType,
10520 d = n.adUrl,
10521 u = n.renderer;
10522 if (u && u.url) u.render(n);
10523 else if (e === document && !w.inIframe() || "video" === a) w.logError("Error trying to write ad. Ad render call ad id " + t + " was prevented from writing to the main document.");
10524 else if (o) e.write(o), e.close(), s(e, i, r);
10525 else if (d) {
10526 var c = w.createInvisibleIframe();
10527 c.height = r, c.width = i, c.style.display = "inline", c.src = d, w.insertElement(c, e, "body"), s(e, i, r)
10528 } else w.logError("Error trying to write ad. No ad for bid response id: " + t)
10529 } else w.logError("Error trying to write ad. Cannot find ad by given id : " + t)
10530 } catch (l) {
10531 w.logError("Error trying to write ad Id :" + t + " to the page:" + l.message)
10532 } else w.logError("Error trying to write ad Id :" + t + " to the page. Missing document or adId")
10533 }, _.removeAdUnit = function(e) {
10534 if (w.logInfo("Invoking pbjs.removeAdUnit", arguments), e)
10535 for (var t = 0; t < _.adUnits.length; t++) _.adUnits[t].code === e && _.adUnits.splice(t, 1)
10536 }, _.clearAuction = function() {
10537 U = !1, v.syncCookies(_.cookieSyncDelay), w.logMessage("Prebid auction cleared"), q.length && q.shift()()
10538 }, _.requestBids = function() {
10539 var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
10540 t = e.bidsBackHandler,
10541 n = e.timeout,
10542 r = e.adUnits,
10543 i = e.adUnitCodes;
10544 x.emit("requestBids");
10545 var o = _.cbTimeout = n || _.bidderTimeout;
10546 r = r || _.adUnits, w.logInfo("Invoking pbjs.requestBids", arguments), i && i.length ? r = r.filter((function(e) {
10547 return i.includes(e.code)
10548 })) : i = r && r.map((function(e) {
10549 return e.code
10550 }));
10551 var s = r.filter(f.videoAdUnit).filter(f.hasNonVideoBidder);
10552 if (s.forEach((function(e) {
10553 w.logError("adUnit " + e.code + " has 'mediaType' set to 'video' but contains a bidder that doesn't support video. No Prebid demand requests will be triggered for this adUnit.");
10554 for (var t = 0; t < r.length; t++) r[t].code === e.code && r.splice(t, 1)
10555 })), r.filter(p.nativeAdUnit).filter(p.hasNonNativeBidder).forEach((function(e) {
10556 var t = e.bids.filter((function(e) {
10557 return !p.nativeBidder(e)
10558 })).map((function(e) {
10559 return e.bidder
10560 })).join(", ");
10561 w.logError("adUnit " + e.code + " has 'mediaType' set to 'native' but contains non-native bidder(s) " + t + ". No Prebid demand requests will be triggered for those bidders."), e.bids = e.bids.filter(p.nativeBidder)
10562 })), U) return q.push((function() {
10563 _.requestBids({
10564 bidsBackHandler: t,
10565 timeout: o,
10566 adUnits: r,
10567 adUnitCodes: i
10568 })
10569 })), void 0;
10570 if (U = !0, _._adUnitCodes = i, T.externalCallbackReset(), a(), !r || 0 === r.length) return w.logMessage("No adUnits configured. No bids requested."), ("undefined" == typeof t ? "undefined" : u(t)) === B && T.addOneTimeCallback(t, !1), T.executeCallback(), void 0;
10571 var d = !0,
10572 c = T.executeCallback.bind(T, d),
10573 l = setTimeout(c, o);
10574 h.setAjaxTimeout(o), ("undefined" == typeof t ? "undefined" : u(t)) === B && T.addOneTimeCallback(t, l), E.callBids({
10575 adUnits: r,
10576 adUnitCodes: i,
10577 cbTimeout: o
10578 }), 0 === _._bidsRequested.length && T.executeCallback()
10579 }, _.addAdUnits = function(e) {
10580 w.logInfo("Invoking pbjs.addAdUnits", arguments), w.isArray(e) ? (e.forEach((function(e) {
10581 return e.transactionId = w.generateUUID()
10582 })), _.adUnits.push.apply(_.adUnits, e)) : ("undefined" == typeof e ? "undefined" : u(e)) === C && (e.transactionId = w.generateUUID(), _.adUnits.push(e))
10583 }, _.onEvent = function(e, t, n) {
10584 return w.logInfo("Invoking pbjs.onEvent", arguments), w.isFn(t) ? n && !N[e].call(null, n) ? (w.logError('The id provided is not valid for event "' + e + '" and no handler was set.'), void 0) : (x.on(e, t, n), void 0) : (w.logError('The event handler provided is not a function and was not set on event "' + e + '".'), void 0)
10585 }, _.offEvent = function(e, t, n) {
10586 w.logInfo("Invoking pbjs.offEvent", arguments), (!n || N[e].call(null, n)) && x.off(e, t, n)
10587 }, _.addCallback = function(e, t) {
10588 w.logInfo("Invoking pbjs.addCallback", arguments);
10589 var n = null;
10590 return e && t && ("undefined" == typeof t ? "undefined" : u(t)) === B ? (n = w.getUniqueIdentifierStr, T.addCallback(n, t, e), n) : (w.logError("error registering callback. Check method signature"), n)
10591 }, _.removeCallback = function() {
10592 return null
10593 }, _.registerBidAdapter = function(e, t) {
10594 w.logInfo("Invoking pbjs.registerBidAdapter", arguments);
10595 try {
10596 E.registerBidAdapter(e(), t)
10597 } catch (n) {
10598 w.logError("Error registering bidder adapter : " + n.message)
10599 }
10600 }, _.registerAnalyticsAdapter = function(e) {
10601 w.logInfo("Invoking pbjs.registerAnalyticsAdapter", arguments);
10602 try {
10603 E.registerAnalyticsAdapter(e)
10604 } catch (t) {
10605 w.logError("Error registering analytics adapter : " + t.message)
10606 }
10607 }, _.bidsAvailableForAdapter = function(e) {
10608 w.logInfo("Invoking pbjs.bidsAvailableForAdapter", arguments), _._bidsRequested.find((function(t) {
10609 return t.bidderCode === e
10610 })).bids.map((function(t) {
10611 return d(t, S.createBid(1), {
10612 bidderCode: e,
10613 adUnitCode: t.placementCode
10614 })
10615 })).map((function(e) {
10616 return _._bidsReceived.push(e)
10617 }))
10618 }, _.createBid = function(e) {
10619 return w.logInfo("Invoking pbjs.createBid", arguments), S.createBid(e)
10620 }, _.addBidResponse = function(e, t) {
10621 w.logInfo("Invoking pbjs.addBidResponse", arguments), T.addBidResponse(e, t)
10622 }, _.loadScript = function(e, t, n) {
10623 w.logInfo("Invoking pbjs.loadScript", arguments), y.loadScript(e, t, n)
10624 }, _.enableAnalytics = function(e) {
10625 e && !w.isEmpty(e) ? (w.logInfo("Invoking pbjs.enableAnalytics for: ", e), E.enableAnalytics(e)) : w.logError("pbjs.enableAnalytics should be called with option {}")
10626 }, _.aliasBidder = function(e, t) {
10627 w.logInfo("Invoking pbjs.aliasBidder", arguments), e && t ? E.aliasBidAdapter(e, t) : w.logError("bidderCode and alias must be passed as arguments", "pbjs.aliasBidder")
10628 }, _.setPriceGranularity = function(e) {
10629 if (w.logInfo("Invoking pbjs.setPriceGranularity", arguments), !e) return w.logError("Prebid Error: no value passed to `setPriceGranularity()`"), void 0;
10630 if ("string" == typeof e) T.setPriceGranularity(e);
10631 else if ("object" === ("undefined" == typeof e ? "undefined" : u(e))) {
10632 if (!m.isValidePriceConfig(e)) return w.logError("Invalid custom price value passed to `setPriceGranularity()`"), void 0;
10633 T.setCustomPriceBucket(e), T.setPriceGranularity(I.GRANULARITY_OPTIONS.CUSTOM), w.logMessage("Using custom price granularity")
10634 }
10635 }, _.enableSendAllBids = function() {
10636 _._sendAllBids = !0
10637 }, _.getAllWinningBids = function() {
10638 return _._winningBids
10639 }, _.buildMasterVideoTagFromAdserverTag = function(e, t) {
10640 w.logInfo("Invoking pbjs.buildMasterVideoTagFromAdserverTag", arguments);
10641 var n = g.parse(e);
10642 if (0 === _._bidsReceived.length) return e;
10643 var r = "";
10644 if ("dfp" !== t.adserver.toLowerCase()) return w.logError("Only DFP adserver is supported"), void 0;
10645 var i = A.dfpAdserver(t, n);
10646 return i.verifyAdserverTag() || w.logError("Invalid adserverTag, required google params are missing in query string"), i.appendQueryParams(), r = g.format(i.urlComponents)
10647 }, _.setBidderSequence = function(e) {
10648 e === I.ORDER.RANDOM && E.setBidderSequence(I.ORDER.RANDOM)
10649 }, _.getHighestCpmBids = function(e) {
10650 return D.getWinningBids(e)
10651 }, _.setS2SConfig = function(e) {
10652 if (!w.contains(Object.keys(e), "accountId")) return w.logError("accountId missing in Server to Server config"), void 0;
10653 if (!w.contains(Object.keys(e), "bidders")) return w.logError("bidders missing in Server to Server config"), void 0;
10654 var t = d({
10655 enabled: !1,
10656 endpoint: I.S2S.DEFAULT_ENDPOINT,
10657 timeout: 1e3,
10658 maxBids: 1,
10659 adapter: "prebidServer"
10660 }, e);
10661 E.setS2SConfig(t)
10662 }, _.cmd.push((function() {
10663 return b.listenMessagesFromCreative()
10664 })), i(_.cmd), i(_.que)
10665}), (function(e, t) {
10666 "use strict";
10667
10668 function n() {
10669 return window.pbjs
10670 }
10671 Object.defineProperty(t, "__esModule", {
10672 value: !0
10673 }), t.getGlobal = n, window.pbjs = window.pbjs || {}, window.pbjs.cmd = window.pbjs.cmd || [], window.pbjs.que = window.pbjs.que || []
10674}), (function(e, t, n) {
10675 "use strict";
10676
10677 function r() {
10678 return q() + Math.random().toString(16).substr(2)
10679 }
10680
10681 function i() {
10682 return window.console && window.console.log
10683 }
10684
10685 function o(e, t, n) {
10686 return n.indexOf(e) === t
10687 }
10688
10689 function a(e, t) {
10690 return e.concat(t)
10691 }
10692
10693 function s(e) {
10694 return pbjs._bidsRequested.map((function(t) {
10695 return t.bids.find((function(t) {
10696 return t.bidId === e
10697 }))
10698 })).find((function(e) {
10699 return e
10700 }))
10701 }
10702
10703 function d(e) {
10704 return Object.keys(e)
10705 }
10706
10707 function u(e, t) {
10708 return e[t]
10709 }
10710
10711 function c() {
10712 var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : pbjs.adUnits;
10713 return e.map((function(e) {
10714 return e.bids.map((function(e) {
10715 return e.bidder
10716 })).reduce(a, [])
10717 })).reduce(a).filter(o)
10718 }
10719
10720 function l() {
10721 return window.googletag && t.isFn(window.googletag.pubads) && t.isFn(window.googletag.pubads().getSlots) ? !0 : void 0
10722 }
10723
10724 function f(e, t) {
10725 return e.cpm === t.cpm ? e.timeToRespond > t.timeToRespond ? t : e : e.cpm < t.cpm ? t : e
10726 }
10727
10728 function p(e) {
10729 for (var t = e.length; t > 0;) {
10730 var n = Math.floor(Math.random() * t);
10731 t--;
10732 var r = e[t];
10733 e[t] = e[n], e[n] = r
10734 }
10735 return e
10736 }
10737
10738 function g(e, t) {
10739 return e.includes(t && t.placementCode || t && t.adUnitCode)
10740 }
10741
10742 function m(e) {
10743 return e.defaultView && e.defaultView.frameElement && "srcdoc" in e.defaultView.frameElement && !/firefox/i.test(navigator.userAgent)
10744 }
10745
10746 function b(e) {
10747 return JSON.parse(JSON.stringify(e))
10748 }
10749
10750 function v() {
10751 try {
10752 return window.self !== window.top
10753 } catch (e) {
10754 return !0
10755 }
10756 }
10757
10758 function y() {
10759 return /^((?!chrome|android).)*safari/i.test(navigator.userAgent)
10760 }
10761
10762 function h(e, t) {
10763 return e ? e.replace(/\$\{AUCTION_PRICE\}/g, t) : void 0
10764 }
10765
10766 function _(e) {
10767 return pbjs._bidsRequested.find((function(t) {
10768 return t.bidderCode === e
10769 }))
10770 }
10771
10772 function I(e, t) {
10773 return pbjs._bidsRequested.find((function(n) {
10774 return n.bids.filter((function(n) {
10775 return n.bidder === e && n.placementCode === t
10776 })).length > 0
10777 })) || {
10778 start: null,
10779 requestId: null
10780 }
10781 }
10782 Object.defineProperty(t, "__esModule", {
10783 value: !0
10784 });
10785 var w = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
10786 return typeof e
10787 } : function(e) {
10788 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
10789 };
10790 t.uniques = o, t.flatten = a, t.getBidRequest = s, t.getKeys = d, t.getValue = u, t.getBidderCodes = c, t.isGptPubadsDefined = l, t.getHighestCpm = f, t.shuffle = p, t.adUnitsFilter = g, t.isSrcdocSupported = m, t.cloneJson = b, t.inIframe = v, t.isSafariBrowser = y, t.replaceAuctionPrice = h, t.getBidderRequestAllAdUnits = _, t.getBidderRequest = I;
10791 var T = n(3),
10792 E = "object",
10793 S = "string",
10794 x = "number",
10795 A = !1,
10796 D = "Array",
10797 B = "String",
10798 R = "Function",
10799 C = "Number",
10800 j = Object.prototype.toString,
10801 O = null;
10802 try {
10803 O = console.info.bind(window.console)
10804 } catch (U) {}
10805 t.replaceTokenInString = function(e, t, n) {
10806 return this._each(t, (function(t, r) {
10807 t = void 0 === t ? "" : t;
10808 var i = n + r.toUpperCase() + n,
10809 o = new RegExp(i, "g");
10810 e = e.replace(o, t)
10811 })), e
10812 };
10813 var q = (function() {
10814 var e = 0;
10815 return function() {
10816 return e++, e
10817 }
10818 })();
10819 t.getUniqueIdentifierStr = r, t.generateUUID = function z(e) {
10820 return e ? (e ^ 16 * Math.random() >> e / 4).toString(16) : ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, z)
10821 }, t.getBidIdParameter = function(e, t) {
10822 return t && t[e] ? t[e] : ""
10823 }, t.tryAppendQueryString = function(e, t, n) {
10824 return n ? e += t + "=" + encodeURIComponent(n) + "&" : e
10825 }, t.parseQueryStringParameters = function(e) {
10826 var t = "";
10827 for (var n in e) e.hasOwnProperty(n) && (t += n + "=" + encodeURIComponent(e[n]) + "&");
10828 return t
10829 }, t.transformAdServerTargetingObj = function(e) {
10830 return e && Object.getOwnPropertyNames(e).length > 0 ? d(e).map((function(t) {
10831 return t + "=" + encodeURIComponent(u(e, t))
10832 })).join("&") : ""
10833 }, t.parseSizesInput = function(e) {
10834 var t = [];
10835 if (("undefined" == typeof e ? "undefined" : w(e)) === S) {
10836 var n = e.split(","),
10837 r = /^(\d)+x(\d)+$/i;
10838 if (n)
10839 for (var i in n) M(n, i) && n[i].match(r) && t.push(n[i])
10840 } else if (("undefined" == typeof e ? "undefined" : w(e)) === E) {
10841 var o = e.length;
10842 if (o > 0)
10843 if (2 === o && w(e[0]) === x && w(e[1]) === x) t.push(this.parseGPTSingleSizeArray(e));
10844 else
10845 for (var a = 0; o > a; a++) t.push(this.parseGPTSingleSizeArray(e[a]))
10846 }
10847 return t
10848 }, t.parseGPTSingleSizeArray = function(e) {
10849 return !this.isArray(e) || 2 !== e.length || isNaN(e[0]) || isNaN(e[1]) ? void 0 : e[0] + "x" + e[1]
10850 }, t.getTopWindowLocation = function() {
10851 var e = void 0;
10852 try {
10853 e = window.top.location
10854 } catch (t) {
10855 e = window.location
10856 }
10857 return e
10858 }, t.getTopWindowUrl = function() {
10859 var e = void 0;
10860 try {
10861 e = this.getTopWindowLocation().href
10862 } catch (t) {
10863 e = ""
10864 }
10865 return e
10866 }, t.logWarn = function(e) {
10867 P() && console.warn && console.warn("WARNING: " + e)
10868 }, t.logInfo = function(e, t) {
10869 P() && i() && O && (t && 0 !== t.length || (t = ""), O("INFO: " + e + ("" === t ? "" : " : params : "), t))
10870 }, t.logMessage = function(e) {
10871 P() && i() && console.log("MESSAGE: " + e)
10872 }, t.hasConsoleLogger = i;
10873 var N = (function(e) {
10874 return e ? window.console.error ? "error" : "log" : ""
10875 })(i()),
10876 P = function() {
10877 return pbjs.logging === !1 && A === !1 && (pbjs.logging = "TRUE" === k(T.DEBUG_MODE).toUpperCase(), A = !0), !!pbjs.logging
10878 };
10879 t.debugTurnedOn = P, t.logError = function(e, t, n) {
10880 var r = t || "ERROR";
10881 P() && i() && console[N](console, r + ": " + e, n || "")
10882 }, t.createInvisibleIframe = function() {
10883 var e = document.createElement("iframe");
10884 return e.id = r(), e.height = 0, e.width = 0, e.border = "0px", e.hspace = "0", e.vspace = "0", e.marginWidth = "0", e.marginHeight = "0", e.style.border = "0", e.scrolling = "no", e.frameBorder = "0", e.src = "about:blank", e.style.display = "none", e
10885 };
10886 var k = function(e) {
10887 var t = "[\\?&]" + e + "=([^&#]*)",
10888 n = new RegExp(t),
10889 r = n.exec(window.location.search);
10890 return null === r ? "" : decodeURIComponent(r[1].replace(/\+/g, " "))
10891 };
10892 t.hasValidBidRequest = function(e, t, n) {
10893 function r(e, n) {
10894 n === t[o] && (i = !0)
10895 }
10896 for (var i = !1, o = 0; o < t.length; o++)
10897 if (i = !1, this._each(e, r), !i) return this.logError("Params are missing for bid request. One of these required paramaters are missing: " + t, n), !1;
10898 return !0
10899 }, t.addEventHandler = function(e, t, n) {
10900 e.addEventListener ? e.addEventListener(t, n, !0) : e.attachEvent && e.attachEvent("on" + t, n)
10901 }, t.isA = function(e, t) {
10902 return j.call(e) === "[object " + t + "]"
10903 }, t.isFn = function(e) {
10904 return this.isA(e, R)
10905 }, t.isStr = function(e) {
10906 return this.isA(e, B)
10907 }, t.isArray = function(e) {
10908 return this.isA(e, D)
10909 }, t.isNumber = function(e) {
10910 return this.isA(e, C)
10911 }, t.isEmpty = function(e) {
10912 if (!e) return !0;
10913 if (this.isArray(e) || this.isStr(e)) return !(e.length > 0);
10914 for (var t in e)
10915 if (hasOwnProperty.call(e, t)) return !1;
10916 return !0
10917 }, t.isEmptyStr = function(e) {
10918 return this.isStr(e) && (!e || 0 === e.length)
10919 }, t._each = function(e, t) {
10920 if (!this.isEmpty(e)) {
10921 if (this.isFn(e.forEach)) return e.forEach(t, this);
10922 var n = 0,
10923 r = e.length;
10924 if (r > 0)
10925 for (; r > n; n++) t(e[n], n, e);
10926 else
10927 for (n in e) hasOwnProperty.call(e, n) && t.call(this, e[n], n)
10928 }
10929 }, t.contains = function(e, t) {
10930 if (this.isEmpty(e)) return !1;
10931 if (this.isFn(e.indexOf)) return -1 !== e.indexOf(t);
10932 for (var n = e.length; n--;)
10933 if (e[n] === t) return !0;
10934 return !1
10935 }, t.indexOf = (function() {
10936 return Array.prototype.indexOf ? Array.prototype.indexOf : void 0
10937 })(), t._map = function(e, t) {
10938 if (this.isEmpty(e)) return [];
10939 if (this.isFn(e.map)) return e.map(t);
10940 var n = [];
10941 return this._each(e, (function(r, i) {
10942 n.push(t(r, i, e))
10943 })), n
10944 };
10945 var M = function(e, t) {
10946 return e.hasOwnProperty ? e.hasOwnProperty(t) : "undefined" != typeof e[t] && e.constructor.prototype[t] !== e[t]
10947 };
10948 t.insertElement = function(e, t, n) {
10949 t = t || document;
10950 var r = void 0;
10951 r = n ? t.getElementsByTagName(n) : t.getElementsByTagName("head");
10952 try {
10953 r = r.length ? r : t.getElementsByTagName("body"), r.length && (r = r[0], r.insertBefore(e, r.firstChild))
10954 } catch (i) {}
10955 }, t.insertPixel = function(e) {
10956 var t = new Image;
10957 t.id = this.getUniqueIdentifierStr(), t.src = e, t.height = 0, t.width = 0, t.style.display = "none", t.onload = function() {
10958 try {
10959 this.parentNode.removeChild(this)
10960 } catch (e) {}
10961 }, this.insertElement(t)
10962 }, t.insertCookieSyncIframe = function(e, t) {
10963 var n = this.createTrackPixelIframeHtml(e, t),
10964 r = document.createElement("div");
10965 r.innerHTML = n;
10966 var i = r.firstChild;
10967 this.insertElement(i)
10968 }, t.createTrackPixelHtml = function(e) {
10969 if (!e) return "";
10970 var t = encodeURI(e),
10971 n = '<div style="position:absolute;left:0px;top:0px;visibility:hidden;">';
10972 return n += '<img src="' + t + '"></div>'
10973 }, t.createTrackPixelIframeHtml = function(e) {
10974 var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : !0;
10975 return e ? (t && (e = encodeURI(e)), '<iframe frameborder="0" allowtransparency="true" marginheight="0" marginwidth="0" width="0" hspace="0" vspace="0" height="0" style="height:0p;width:0p;display:none;" scrolling="no" src="' + e + '"></iframe>') : ""
10976 }, t.getIframeDocument = function(e) {
10977 if (e) {
10978 var t = void 0;
10979 try {
10980 t = e.contentWindow ? e.contentWindow.document : e.contentDocument.document ? e.contentDocument.document : e.contentDocument
10981 } catch (n) {
10982 this.logError("Cannot get iframe document", n)
10983 }
10984 return t
10985 }
10986 }, t.getValueString = function(e, t, n) {
10987 return void 0 === t || null === t ? n : this.isStr(t) ? t : this.isNumber(t) ? t.toString() : (this.logWarn("Unsuported type for param: " + e + " required type: String"), void 0)
10988 }
10989}), (function(e) {
10990 e.exports = {
10991 JSON_MAPPING: {
10992 PL_CODE: "code",
10993 PL_SIZE: "sizes",
10994 PL_BIDS: "bids",
10995 BD_BIDDER: "bidder",
10996 BD_ID: "paramsd",
10997 BD_PL_ID: "placementId",
10998 ADSERVER_TARGETING: "adserverTargeting",
10999 BD_SETTING_STANDARD: "standard"
11000 },
11001 REPO_AND_VERSION: "prebid_prebid_0.24.1",
11002 DEBUG_MODE: "pbjs_debug",
11003 STATUS: {
11004 GOOD: 1,
11005 NO_BID: 2
11006 },
11007 CB: {
11008 TYPE: {
11009 ALL_BIDS_BACK: "allRequestedBidsBack",
11010 AD_UNIT_BIDS_BACK: "adUnitBidsBack",
11011 BID_WON: "bidWon",
11012 REQUEST_BIDS: "requestBids"
11013 }
11014 },
11015 objectType_function: "function",
11016 objectType_undefined: "undefined",
11017 objectType_object: "object",
11018 objectType_string: "string",
11019 objectType_number: "number",
11020 EVENTS: {
11021 AUCTION_INIT: "auctionInit",
11022 AUCTION_END: "auctionEnd",
11023 BID_ADJUSTMENT: "bidAdjustment",
11024 BID_TIMEOUT: "bidTimeout",
11025 BID_REQUESTED: "bidRequested",
11026 BID_RESPONSE: "bidResponse",
11027 BID_WON: "bidWon",
11028 SET_TARGETING: "setTargeting",
11029 REQUEST_BIDS: "requestBids"
11030 },
11031 EVENT_ID_PATHS: {
11032 bidWon: "adUnitCode"
11033 },
11034 ORDER: {
11035 RANDOM: "random"
11036 },
11037 GRANULARITY_OPTIONS: {
11038 LOW: "low",
11039 MEDIUM: "medium",
11040 HIGH: "high",
11041 AUTO: "auto",
11042 DENSE: "dense",
11043 CUSTOM: "custom"
11044 },
11045 TARGETING_KEYS: ["hb_bidder", "hb_adid", "hb_pb", "hb_size", "hb_deal"],
11046 S2S: {
11047 DEFAULT_ENDPOINT: "https://prebid.adnxs.com/pbs/v1/auction"
11048 }
11049 }
11050}), (function(e, t, n) {
11051 "use strict";
11052 Object.defineProperty(t, "__esModule", {
11053 value: !0
11054 }), t.hasNonVideoBidder = t.videoAdUnit = void 0; {
11055 var r = n(5),
11056 i = (t.videoAdUnit = function(e) {
11057 return "video" === e.mediaType
11058 }, function(e) {
11059 return !r.videoAdapters.includes(e.bidder)
11060 });
11061 t.hasNonVideoBidder = function(e) {
11062 return e.bids.filter(i).length
11063 }
11064 }
11065}), (function(e, t, n) {
11066 "use strict";
11067
11068 function r(e) {
11069 return e && e.__esModule ? e : {
11070 "default": e
11071 }
11072 }
11073
11074 function i(e) {
11075 var t = e.bidderCode,
11076 n = e.requestId,
11077 r = e.bidderRequestId,
11078 i = e.adUnits;
11079 return i.map((function(e) {
11080 return e.bids.filter((function(e) {
11081 return e.bidder === t
11082 })).map((function(t) {
11083 var i = e.sizes;
11084 if (e.sizeMapping) {
11085 var o = u.mapSizes(e);
11086 if ("" === o) return "";
11087 i = o
11088 }
11089 return e.nativeParams && (t = s({}, t, {
11090 nativeParams: l["default"](e.nativeParams)
11091 })), s({}, t, {
11092 placementCode: e.code,
11093 mediaType: e.mediaType,
11094 transactionId: e.transactionId,
11095 sizes: i,
11096 bidId: t.bid_id || p.getUniqueIdentifierStr(),
11097 bidderRequestId: r,
11098 requestId: n
11099 })
11100 }))
11101 })).reduce(d.flatten, []).filter((function(e) {
11102 return "" !== e
11103 }))
11104 }
11105
11106 function o(e) {
11107 var t = [],
11108 n = p.parseSizesInput(e.sizes);
11109 return n.forEach((function(e) {
11110 var n = e.split("x"),
11111 r = {
11112 w: parseInt(n[0]),
11113 h: parseInt(n[1])
11114 };
11115 t.push(r)
11116 })), t
11117 }
11118 var a = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
11119 return typeof e
11120 } : function(e) {
11121 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
11122 },
11123 s = Object.assign || function(e) {
11124 for (var t = 1; t < arguments.length; t++) {
11125 var n = arguments[t];
11126 for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
11127 }
11128 return e
11129 },
11130 d = n(2),
11131 u = n(6),
11132 c = n(7),
11133 l = r(c),
11134 f = n(8),
11135 p = n(2),
11136 g = n(3),
11137 m = n(9),
11138 b = {};
11139 t.bidderRegistry = b;
11140 var v = {},
11141 y = {},
11142 h = null;
11143 t.callBids = function(e) {
11144 var t = e.adUnits,
11145 n = e.cbTimeout,
11146 r = p.generateUUID(),
11147 a = Date.now(),
11148 s = {
11149 timestamp: a,
11150 requestId: r
11151 };
11152 m.emit(g.EVENTS.AUCTION_INIT, s);
11153 var c = d.getBidderCodes(t);
11154 if (h === g.ORDER.RANDOM && (c = d.shuffle(c)), v.enabled) {
11155 var l = v.bidders;
11156 c = c.filter((function(e) {
11157 return !l.includes(e)
11158 }));
11159 var f = p.cloneJson(t);
11160 f.forEach((function(e) {
11161 e.sizeMapping && (e.sizes = u.mapSizes(e), delete e.sizeMapping), e.sizes = o(e), e.bids = e.bids.filter((function(e) {
11162 return l.includes(e.bidder)
11163 })).map((function(e) {
11164 return e.bid_id = p.getUniqueIdentifierStr(), e
11165 }))
11166 }));
11167 var y = p.generateUUID();
11168 l.forEach((function(e) {
11169 var t = p.getUniqueIdentifierStr(),
11170 n = {
11171 bidderCode: e,
11172 requestId: r,
11173 bidderRequestId: t,
11174 tid: y,
11175 bids: i({
11176 bidderCode: e,
11177 requestId: r,
11178 bidderRequestId: t,
11179 adUnits: f
11180 }),
11181 start: (new Date).getTime(),
11182 auctionStart: a,
11183 timeout: v.timeout
11184 };
11185 pbjs._bidsRequested.push(n)
11186 }));
11187 var _ = {
11188 tid: y,
11189 ad_units: f
11190 },
11191 I = b[v.adapter];
11192 p.logMessage("CALLING S2S HEADER BIDDERS ==== " + l.join(",")), I.setConfig(v), I.callBids(_)
11193 }
11194 c.forEach((function(e) {
11195 var o = b[e];
11196 if (o) {
11197 var s = p.getUniqueIdentifierStr(),
11198 d = {
11199 bidderCode: e,
11200 requestId: r,
11201 bidderRequestId: s,
11202 bids: i({
11203 bidderCode: e,
11204 requestId: r,
11205 bidderRequestId: s,
11206 adUnits: t
11207 }),
11208 start: (new Date).getTime(),
11209 auctionStart: a,
11210 timeout: n
11211 };
11212 d.bids && 0 !== d.bids.length && (p.logMessage("CALLING BIDDER ======= " + e), pbjs._bidsRequested.push(d), m.emit(g.EVENTS.BID_REQUESTED, d), o.callBids(d))
11213 } else p.logError("Adapter trying to be called which does not exist: " + e + " adaptermanager.callBids")
11214 }))
11215 }, t.registerBidAdapter = function(e, t) {
11216 e && t ? a(e.callBids) === g.objectType_function ? b[t] = e : p.logError("Bidder adaptor error for bidder code: " + t + "bidder must implement a callBids() function") : p.logError("bidAdaptor or bidderCode not specified")
11217 }, t.aliasBidAdapter = function(e, t) {
11218 var n = b[t];
11219 if (("undefined" == typeof n ? "undefined" : a(n)) === g.objectType_undefined) {
11220 var r = b[e];
11221 if (("undefined" == typeof r ? "undefined" : a(r)) === g.objectType_undefined) p.logError('bidderCode "' + e + '" is not an existing bidder.', "adaptermanager.aliasBidAdapter");
11222 else try {
11223 var i = null;
11224 r instanceof f.BaseAdapter ? p.logError(e + " bidder does not currently support aliasing.", "adaptermanager.aliasBidAdapter") : (i = r.createNew(), i.setBidderCode(t), this.registerBidAdapter(i, t))
11225 } catch (o) {
11226 p.logError(e + " bidder does not currently support aliasing.", "adaptermanager.aliasBidAdapter")
11227 }
11228 } else p.logMessage('alias name "' + t + '" has been already specified.')
11229 }, t.registerAnalyticsAdapter = function(e) {
11230 var t = e.adapter,
11231 n = e.code;
11232 t && n ? a(t.enableAnalytics) === g.objectType_function ? (t.code = n, y[n] = t) : p.logError('Prebid Error: Analytics adaptor error for analytics "' + n + '"\n analytics adapter must implement an enableAnalytics() function') : p.logError("Prebid Error: analyticsAdapter or analyticsCode not specified")
11233 }, t.enableAnalytics = function(e) {
11234 p.isArray(e) || (e = [e]), p._each(e, (function(e) {
11235 var t = y[e.provider];
11236 t ? t.enableAnalytics(e) : p.logError("Prebid Error: no analytics adapter found in registry for\n " + e.provider + ".")
11237 }))
11238 }, t.setBidderSequence = function(e) {
11239 h = e
11240 }, t.setS2SConfig = function(e) {
11241 v = e
11242 };
11243 var _ = n(10);
11244 t.registerBidAdapter(new _, "appnexus");
11245 var I = n(16);
11246 t.registerBidAdapter(new I, "indexExchange");
11247 var w = n(17);
11248 t.registerBidAdapter(new w, "pubmatic");
11249 var T = n(18);
11250 t.registerBidAdapter(new T, "rubicon");
11251 var E = n(21);
11252 t.registerBidAdapter(new E, "criteo"), t.aliasBidAdapter("appnexus", "brealtime"), t.aliasBidAdapter("appnexus", "pagescience"), t.aliasBidAdapter("appnexus", "defymedia"), t.aliasBidAdapter("rubicon", "rubiconLite"), t.aliasBidAdapter("appnexus", "featureforward"), t.videoAdapters = ["appnexusAst"]
11253}), (function(e, t, n) {
11254 "use strict";
11255
11256 function r(e) {
11257 if (e && e.__esModule) return e;
11258 var t = {};
11259 if (null != e)
11260 for (var n in e) Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
11261 return t["default"] = e, t
11262 }
11263
11264 function i(e) {
11265 if (!o(e.sizeMapping)) return e.sizes;
11266 var t = a();
11267 if (!t) {
11268 var n = e.sizeMapping.reduce((function(e, t) {
11269 return e.minWidth < t.minWidth ? t : e
11270 }));
11271 return n.sizes && n.sizes.length ? n.sizes : e.sizes
11272 }
11273 var r = "",
11274 i = e.sizeMapping.find((function(e) {
11275 return t > e.minWidth
11276 }));
11277 return i && i.sizes && i.sizes.length ? (r = i.sizes, u.logMessage("AdUnit : " + e.code + " resized based on device width to : " + r)) : u.logMessage("AdUnit : " + e.code + " not mapped to any sizes for device width. This request will be suppressed."), r
11278 }
11279
11280 function o(e) {
11281 return u.isArray(e) && e.length > 0 ? !0 : (u.logInfo("No size mapping defined"), !1)
11282 }
11283
11284 function a(e) {
11285 var t = e || c || window,
11286 n = t.document;
11287 return t.innerWidth ? t.innerWidth : n.body.clientWidth ? n.body.clientWidth : n.documentElement.clientWidth ? n.documentElement.clientWidth : 0
11288 }
11289
11290 function s(e) {
11291 c = e
11292 }
11293 Object.defineProperty(t, "__esModule", {
11294 value: !0
11295 }), t.setWindow = t.getScreenWidth = t.mapSizes = void 0;
11296 var d = n(2),
11297 u = r(d),
11298 c = void 0;
11299 t.mapSizes = i, t.getScreenWidth = a, t.setWindow = s
11300}), (function(e, t, n) {
11301 "use strict";
11302
11303 function r(e) {
11304 return e && e.type && i(e.type) ? l[e.type] : e
11305 }
11306
11307 function i(e) {
11308 return e && Object.keys(l).includes(e) ? !0 : (s.logError(e + " nativeParam is not supported"), !1)
11309 }
11310
11311 function o(e) {
11312 var t = s.getBidRequest(e.adId);
11313 if (!t) return !1;
11314 var n = t.nativeParams;
11315 if (!n) return !0;
11316 var r = Object.keys(n).filter((function(e) {
11317 return n[e].required
11318 })),
11319 i = Object.keys(e.native);
11320 return r.every((function(e) {
11321 return i.includes(e)
11322 }))
11323 }
11324
11325 function a(e) {
11326 var t = e.native && e.native.impressionTrackers;
11327 (t || []).forEach((function(e) {
11328 s.insertPixel(e)
11329 }))
11330 }
11331 Object.defineProperty(t, "__esModule", {
11332 value: !0
11333 }), t.hasNonNativeBidder = t.nativeBidder = t.nativeAdUnit = t.NATIVE_TARGETING_KEYS = t.NATIVE_KEYS = void 0, t["default"] = r, t.nativeBidIsValid = o, t.fireNativeImpressions = a; {
11334 var s = n(2),
11335 d = ["appnexusAst"],
11336 u = t.NATIVE_KEYS = {
11337 title: "hb_native_title",
11338 body: "hb_native_body",
11339 sponsoredBy: "hb_native_brand",
11340 image: "hb_native_image",
11341 icon: "hb_native_icon",
11342 clickUrl: "hb_native_linkurl"
11343 },
11344 c = (t.NATIVE_TARGETING_KEYS = Object.keys(u).map((function(e) {
11345 return u[e]
11346 })), {
11347 image: {
11348 required: !0
11349 },
11350 title: {
11351 required: !0
11352 },
11353 sponsoredBy: {
11354 required: !0
11355 },
11356 clickUrl: {
11357 required: !0
11358 },
11359 body: {
11360 required: !1
11361 },
11362 icon: {
11363 required: !1
11364 }
11365 }),
11366 l = {
11367 image: c
11368 },
11369 f = (t.nativeAdUnit = function(e) {
11370 return "native" === e.mediaType
11371 }, t.nativeBidder = function(e) {
11372 return d.includes(e.bidder)
11373 });
11374 t.hasNonNativeBidder = function(e) {
11375 return e.bids.filter((function(e) {
11376 return !f(e)
11377 })).length
11378 }
11379 }
11380}), (function(e, t) {
11381 "use strict";
11382
11383 function n(e, t) {
11384 if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
11385 }
11386 Object.defineProperty(t, "__esModule", {
11387 value: !0
11388 }); {
11389 var r = (function() {
11390 function e(e, t) {
11391 for (var n = 0; n < t.length; n++) {
11392 var r = t[n];
11393 r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r)
11394 }
11395 }
11396 return function(t, n, r) {
11397 return n && e(t.prototype, n), r && e(t, r), t
11398 }
11399 })();
11400 t.BaseAdapter = (function() {
11401 function e(t) {
11402 n(this, e), this.code = t
11403 }
11404 return r(e, [{
11405 key: "getCode",
11406 value: function() {
11407 return this.code
11408 }
11409 }, {
11410 key: "setCode",
11411 value: function(e) {
11412 this.code = e
11413 }
11414 }, {
11415 key: "callBids",
11416 value: function() {
11417 throw "adapter implementation must override callBids method"
11418 }
11419 }]), e
11420 })()
11421 }
11422}), (function(e, t, n) {
11423 "use strict";
11424 var r = Object.assign || function(e) {
11425 for (var t = 1; t < arguments.length; t++) {
11426 var n = arguments[t];
11427 for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
11428 }
11429 return e
11430 },
11431 i = n(2),
11432 o = n(3),
11433 a = Array.prototype.slice,
11434 s = Array.prototype.push,
11435 d = i._map(o.EVENTS, (function(e) {
11436 return e
11437 })),
11438 u = o.EVENT_ID_PATHS,
11439 c = [];
11440 e.exports = (function() {
11441 function e(e, t) {
11442 i.logMessage("Emitting event for: " + e);
11443 var r = t[0] || {},
11444 o = u[e],
11445 a = r[o],
11446 d = n[e] || {
11447 que: []
11448 },
11449 l = i._map(d, (function(e, t) {
11450 return t
11451 })),
11452 f = [];
11453 c.push({
11454 eventType: e,
11455 args: r,
11456 id: a
11457 }), a && i.contains(l, a) && s.apply(f, d[a].que), s.apply(f, d.que), i._each(f, (function(e) {
11458 if (e) try {
11459 e.apply(null, t)
11460 } catch (n) {
11461 i.logError("Error executing handler:", "events.js", n)
11462 }
11463 }))
11464 }
11465
11466 function t(e) {
11467 return i.contains(d, e)
11468 }
11469 var n = {},
11470 o = {};
11471 return o.on = function(e, r, o) {
11472 if (t(e)) {
11473 var a = n[e] || {
11474 que: []
11475 };
11476 o ? (a[o] = a[o] || {
11477 que: []
11478 }, a[o].que.push(r)) : a.que.push(r), n[e] = a
11479 } else i.logError("Wrong event name : " + e + " Valid event names :" + d)
11480 }, o.emit = function(t) {
11481 var n = a.call(arguments, 1);
11482 e(t, n)
11483 }, o.off = function(e, t, r) {
11484 var o = n[e];
11485 i.isEmpty(o) || i.isEmpty(o.que) && i.isEmpty(o[r]) || r && (i.isEmpty(o[r]) || i.isEmpty(o[r].que)) || (r ? i._each(o[r].que, (function(e) {
11486 var n = o[r].que;
11487 e === t && n.splice(i.indexOf.call(n, e), 1)
11488 })) : i._each(o.que, (function(e) {
11489 var n = o.que;
11490 e === t && n.splice(i.indexOf.call(n, e), 1)
11491 })), n[e] = o)
11492 }, o.get = function() {
11493 return n
11494 }, o.getEvents = function() {
11495 var e = [];
11496 return i._each(c, (function(t) {
11497 var n = r({}, t);
11498 e.push(n)
11499 })), e
11500 }, o
11501 })()
11502}), (function(e, t, n) {
11503 "use strict";
11504 var r, i = Object.assign || function(e) {
11505 for (var t = 1; t < arguments.length; t++) {
11506 var n = arguments[t];
11507 for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
11508 }
11509 return e
11510 },
11511 o = n(2),
11512 a = n(3),
11513 s = n(2),
11514 d = n(11),
11515 u = n(12),
11516 c = n(14),
11517 l = n(15);
11518 r = function f() {
11519 function e(e, t) {
11520 var n = s.getBidIdParameter("placementId", e.params),
11521 r = s.getBidIdParameter("memberId", e.params),
11522 o = s.getBidIdParameter("member", e.params),
11523 a = s.getBidIdParameter("invCode", e.params),
11524 d = s.getBidIdParameter("query", e.params),
11525 u = s.getBidIdParameter("referrer", e.params),
11526 c = s.getBidIdParameter("alt_referrer", e.params),
11527 l = "http" + ("https:" === document.location.protocol ? "s://secure.adnxs.com/jpt?" : "://ib.adnxs.com/jpt?");
11528 l = s.tryAppendQueryString(l, "callback", "pbjs.handleAnCB"), l = s.tryAppendQueryString(l, "callback_uid", t), l = s.tryAppendQueryString(l, "psa", "0"), l = s.tryAppendQueryString(l, "id", n), o ? l = s.tryAppendQueryString(l, "member", o) : r && (l = s.tryAppendQueryString(l, "member", r), s.logMessage('appnexus.callBids: "memberId" will be deprecated soon. Please use "member" instead')), l = s.tryAppendQueryString(l, "code", a), l = s.tryAppendQueryString(l, "traffic_source_code", s.getBidIdParameter("trafficSourceCode", e.params));
11529 var f = "",
11530 p = s.parseSizesInput(e.sizes),
11531 g = p.length;
11532 if (g > 0 && (f = "size=" + p[0], g > 1)) {
11533 f += "&promo_sizes=";
11534 for (var m = 1; g > m; m++) f += p[m] += ",";
11535 f && "," === f.charAt(f.length - 1) && (f = f.slice(0, f.length - 1))
11536 }
11537 f && (l += f + "&");
11538 var b = s.parseQueryStringParameters(d);
11539 b && (l += b);
11540 var v = i({}, e.params);
11541 delete v.placementId, delete v.memberId, delete v.invCode, delete v.query, delete v.referrer, delete v.alt_referrer, delete v.member;
11542 var y = s.parseQueryStringParameters(v);
11543 return y && (l += y), "" === u && (u = s.getTopWindowUrl()), l = s.tryAppendQueryString(l, "referrer", u), l = s.tryAppendQueryString(l, "alt_referrer", c), l.lastIndexOf("&") === l.length - 1 && (l = l.substring(0, l.length - 1)), s.logMessage("jpt request built: " + l), e.startTime = (new Date).getTime(), l
11544 }
11545 var t = l.createNew("appnexus"),
11546 n = !1;
11547 return t.callBids = function(t) {
11548 for (var n = t.bids, r = 0; r < n.length; r++) {
11549 var i = n[r],
11550 o = i.bidId;
11551 d.loadScript(e(i, o))
11552 }
11553 }, pbjs.handleAnCB = function(e) {
11554 var t;
11555 if (e && e.callback_uid) {
11556 var r, i = e.callback_uid,
11557 d = "",
11558 l = o.getBidRequest(i);
11559 l && (t = l.bidder, d = l.placementCode, l.status = a.STATUS.GOOD), s.logMessage("JSONP callback function called for ad ID: " + i);
11560 var f = [];
11561 if (e.result && e.result.cpm && 0 !== e.result.cpm) {
11562 r = parseInt(e.result.cpm, 10), r /= 1e4;
11563 var p = e.result.creative_id;
11564 f = c.createBid(1, l), f.creative_id = p, f.bidderCode = t, f.cpm = r, f.adUrl = e.result.ad, f.width = e.result.width, f.height = e.result.height, f.dealId = e.result.deal_id, u.addBidResponse(d, f)
11565 } else s.logMessage("No prebid response from AppNexus for placement code " + d), f = c.createBid(2, l), f.bidderCode = t, u.addBidResponse(d, f);
11566 if (!n) {
11567 var g = s.createInvisibleIframe();
11568 g.src = "//acdn.adnxs.com/ib/static/usersync/v3/async_usersync.html";
11569 try {
11570 document.body.appendChild(g)
11571 } catch (m) {
11572 s.logError(m)
11573 }
11574 n = !0
11575 }
11576 } else s.logMessage("No prebid response for placement %%PLACEMENT%%")
11577 }, {
11578 callBids: t.callBids,
11579 setBidderCode: t.setBidderCode,
11580 createNew: f.createNew,
11581 buildJPTCall: e
11582 }
11583 }, r.createNew = function() {
11584 return new r
11585 }, e.exports = r
11586}), (function(e, t, n) {
11587 "use strict";
11588
11589 function r(e, t) {
11590 var n = document.createElement("script");
11591 n.type = "text/javascript", n.async = !0, t && "function" == typeof t && (n.readyState ? n.onreadystatechange = function() {
11592 ("loaded" === n.readyState || "complete" === n.readyState) && (n.onreadystatechange = null, t())
11593 } : n.onload = function() {
11594 t()
11595 }), n.src = e;
11596 var r = document.getElementsByTagName("head");
11597 r = r.length ? r : document.getElementsByTagName("body"), r.length && (r = r[0], r.insertBefore(n, r.firstChild))
11598 }
11599 var i = n(2),
11600 o = {};
11601 t.loadScript = function(e, t, n) {
11602 return e ? (n ? o[e] ? t && "function" == typeof t && (o[e].loaded ? t() : o[e].callbacks.push(t)) : (o[e] = {
11603 loaded: !1,
11604 callbacks: []
11605 }, t && "function" == typeof t && o[e].callbacks.push(t), r(e, (function() {
11606 o[e].loaded = !0;
11607 try {
11608 for (var t = 0; t < o[e].callbacks.length; t++) o[e].callbacks[t]()
11609 } catch (n) {
11610 i.logError("Error executing callback", "adloader.js:loadScript", n)
11611 }
11612 }))) : r(e, t), void 0) : (i.logError("Error attempting to request empty URL", "adloader.js:loadScript"), void 0)
11613 }
11614}), (function(e, t, n) {
11615 "use strict";
11616
11617 function r() {
11618 return (new Date).getTime()
11619 }
11620
11621 function i(e) {
11622 return e.bidderCode
11623 }
11624
11625 function o(e) {
11626 return e.bidder
11627 }
11628
11629 function a(e) {
11630 var t = this,
11631 n = pbjs._bidsRequested.map((function(n) {
11632 return n.bids.filter(h.adUnitsFilter.bind(t, pbjs._adUnitCodes)).filter((function(t) {
11633 return t.placementCode === e
11634 }))
11635 })).reduce(h.flatten, []).map((function(e) {
11636 return "indexExchange" === e.bidder ? e.sizes.length : 1
11637 })).reduce(s, 0),
11638 r = pbjs._bidsReceived.filter((function(t) {
11639 return t.adUnitCode === e
11640 })).length;
11641 return n === r
11642 }
11643
11644 function s(e, t) {
11645 return e + t
11646 }
11647
11648 function d() {
11649 var e = pbjs._bidsRequested.map((function(e) {
11650 return e.bids
11651 })).reduce(h.flatten, []).filter(h.adUnitsFilter.bind(this, pbjs._adUnitCodes)).map((function(e) {
11652 return "indexExchange" === e.bidder ? e.sizes.length : 1
11653 })).reduce((function(e, t) {
11654 return e + t
11655 }), 0),
11656 t = pbjs._bidsReceived.filter(h.adUnitsFilter.bind(this, pbjs._adUnitCodes)).length;
11657 return e === t
11658 }
11659
11660 function u(e, t) {
11661 var n = {},
11662 r = pbjs.bidderSettings;
11663 if (t && r) {
11664 var i = m();
11665 c(n, i, t)
11666 }
11667 return e && t && r && r[e] && r[e][w.JSON_MAPPING.ADSERVER_TARGETING] ? (c(n, r[e], t), t.alwaysUseBid = r[e].alwaysUseBid, t.sendStandardTargeting = r[e].sendStandardTargeting) : R[e] && (c(n, R[e], t), t.alwaysUseBid = R[e].alwaysUseBid, t.sendStandardTargeting = R[e].sendStandardTargeting), t.native && Object.keys(t.native).forEach((function(e) {
11668 var r = I.NATIVE_KEYS[e],
11669 i = t.native[e];
11670 r && (n[r] = i)
11671 })), n
11672 }
11673
11674 function c(e, t, n) {
11675 var r = t[w.JSON_MAPPING.ADSERVER_TARGETING];
11676 return n.size = n.getSize(), E._each(r, (function(r) {
11677 var i = r.key,
11678 o = r.val;
11679 if (e[i] && E.logWarn("The key: " + i + " is getting ovewritten"), E.isFn(o)) try {
11680 o = o(n)
11681 } catch (a) {
11682 E.logError("bidmanager", "ERROR", a)
11683 }("undefined" == typeof t.suppressEmptyKeys || t.suppressEmptyKeys !== !0) && "hb_deal" !== i || !E.isEmptyStr(o) && null !== o && void 0 !== o ? e[i] = o : E.logInfo("suppressing empty key '" + i + "' from adserver targeting")
11684 })), e
11685 }
11686
11687 function l(e) {
11688 var t = [e];
11689 f(A.byAdUnit, t)
11690 }
11691
11692 function f(e, t) {
11693 var n = this;
11694 E.isArray(e) && e.forEach((function(e) {
11695 var r = t || pbjs._adUnitCodes,
11696 i = [pbjs._bidsReceived.filter(h.adUnitsFilter.bind(n, r)).reduce(p, {})];
11697 e.apply(pbjs, i)
11698 }))
11699 }
11700
11701 function p(e, t) {
11702 return e[t.adUnitCode] || (e[t.adUnitCode] = {
11703 bids: []
11704 }), e[t.adUnitCode].bids.push(t), e
11705 }
11706
11707 function g(e) {
11708 var t = e.bidderCode,
11709 n = e.cpm;
11710 if (t && pbjs.bidderSettings && pbjs.bidderSettings[t] && v(pbjs.bidderSettings[t].bidCpmAdjustment) === x) try {
11711 n = pbjs.bidderSettings[t].bidCpmAdjustment.call(null, e.cpm, y({}, e))
11712 } catch (r) {
11713 E.logError("Error during bid adjustment", "bidmanager.js", r)
11714 }
11715 n >= 0 && (e.cpm = n)
11716 }
11717
11718 function m() {
11719 var e = pbjs.bidderSettings;
11720 return e[w.JSON_MAPPING.BD_SETTING_STANDARD] || (e[w.JSON_MAPPING.BD_SETTING_STANDARD] = {
11721 adserverTargeting: [{
11722 key: "hb_bidder",
11723 val: function(e) {
11724 return e.bidderCode
11725 }
11726 }, {
11727 key: "hb_adid",
11728 val: function(e) {
11729 return e.adId
11730 }
11731 }, {
11732 key: "hb_pb",
11733 val: function(e) {
11734 return D === w.GRANULARITY_OPTIONS.AUTO ? e.pbAg : D === w.GRANULARITY_OPTIONS.DENSE ? e.pbDg : D === w.GRANULARITY_OPTIONS.LOW ? e.pbLg : D === w.GRANULARITY_OPTIONS.MEDIUM ? e.pbMg : D === w.GRANULARITY_OPTIONS.HIGH ? e.pbHg : D === w.GRANULARITY_OPTIONS.CUSTOM ? e.pbCg : void 0
11735 }
11736 }, {
11737 key: "hb_size",
11738 val: function(e) {
11739 return e.size
11740 }
11741 }, {
11742 key: "hb_deal",
11743 val: function(e) {
11744 return e.dealId
11745 }
11746 }]
11747 }), e[w.JSON_MAPPING.BD_SETTING_STANDARD]
11748 }
11749
11750 function b() {
11751 return m()[w.JSON_MAPPING.ADSERVER_TARGETING]
11752 }
11753 var v = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
11754 return typeof e
11755 } : function(e) {
11756 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
11757 },
11758 y = Object.assign || function(e) {
11759 for (var t = 1; t < arguments.length; t++) {
11760 var n = arguments[t];
11761 for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
11762 }
11763 return e
11764 },
11765 h = n(2),
11766 _ = n(13),
11767 I = n(7),
11768 w = n(3),
11769 T = w.EVENTS.AUCTION_END,
11770 E = n(2),
11771 S = n(9),
11772 x = "function",
11773 A = {
11774 byAdUnit: [],
11775 all: [],
11776 oneTime: null,
11777 timer: !1
11778 },
11779 D = w.GRANULARITY_OPTIONS.MEDIUM,
11780 B = void 0,
11781 R = {};
11782 t.setCustomPriceBucket = function(e) {
11783 B = e
11784 }, t.getTimedOutBidders = function() {
11785 return pbjs._bidsRequested.map(i).filter(h.uniques).filter((function(e) {
11786 return pbjs._bidsReceived.map(o).filter(h.uniques).indexOf(e) < 0
11787 }))
11788 }, t.bidsBackAll = function() {
11789 return d()
11790 }, t.addBidResponse = function(e, n) {
11791 if (!e) return E.logWarn("No adUnitCode supplied to addBidResponse, response discarded"), void 0;
11792 if (n) {
11793 if ("native" === n.mediaType && !I.nativeBidIsValid(n)) return E.logError("Native bid response does not contain all required assets. This bid won't be addeed to the auction"), void 0;
11794 var i = h.getBidderRequest(n.bidderCode, e),
11795 o = i.requestId,
11796 s = i.start;
11797 if (y(n, {
11798 requestId: o,
11799 responseTimestamp: r(),
11800 requestTimestamp: s,
11801 cpm: parseFloat(n.cpm) || 0,
11802 bidder: n.bidderCode,
11803 adUnitCode: e
11804 }), n.timeToRespond = n.responseTimestamp - n.requestTimestamp, n.timeToRespond > pbjs.cbTimeout + pbjs.timeoutBuffer) {
11805 var c = !0;
11806 t.executeCallback(c)
11807 }
11808 S.emit(w.EVENTS.BID_ADJUSTMENT, n), S.emit(w.EVENTS.BID_RESPONSE, n);
11809 var f = _.getPriceBucketString(n.cpm, B);
11810 n.pbLg = f.low, n.pbMg = f.med, n.pbHg = f.high, n.pbAg = f.auto, n.pbDg = f.dense, n.pbCg = f.custom;
11811 var p = {};
11812 n.bidderCode && (n.cpm > 0 || n.dealId) && (p = u(n.bidderCode, n)), n.adserverTargeting = p, pbjs._bidsReceived.push(n)
11813 }
11814 n && n.adUnitCode && a(n.adUnitCode) && l(n.adUnitCode), d() && t.executeCallback()
11815 }, t.getKeyValueTargetingPairs = function() {
11816 return u.apply(void 0, arguments)
11817 }, t.setPriceGranularity = function(e) {
11818 var t = w.GRANULARITY_OPTIONS;
11819 Object.keys(t).filter((function(n) {
11820 return e === t[n]
11821 })) ? D = e : (E.logWarn("Prebid Warning: setPriceGranularity was called with invalid setting, using `medium` as default."), D = w.GRANULARITY_OPTIONS.MEDIUM)
11822 }, t.registerDefaultBidderSetting = function(e, t) {
11823 R[e] = t
11824 }, t.executeCallback = function(e) {
11825 if (!e && A.timer && clearTimeout(A.timer), A.all.called !== !0 && (f(A.all), A.all.called = !0, e)) {
11826 var n = t.getTimedOutBidders();
11827 n.length && S.emit(w.EVENTS.BID_TIMEOUT, n)
11828 }
11829 if (A.oneTime) {
11830 S.emit(T);
11831 try {
11832 f([A.oneTime])
11833 } catch (r) {
11834 E.logError("Error executing bidsBackHandler", null, r)
11835 } finally {
11836 A.oneTime = null, A.timer = !1, pbjs.clearAuction()
11837 }
11838 }
11839 }, t.externalCallbackReset = function() {
11840 A.all.called = !1
11841 }, t.addOneTimeCallback = function(e, t) {
11842 A.oneTime = e, A.timer = t
11843 }, t.addCallback = function(e, t, n) {
11844 t.id = e, w.CB.TYPE.ALL_BIDS_BACK === n ? A.all.push(t) : w.CB.TYPE.AD_UNIT_BIDS_BACK === n && A.byAdUnit.push(t)
11845 }, S.on(w.EVENTS.BID_ADJUSTMENT, (function(e) {
11846 g(e)
11847 })), t.adjustBids = function() {
11848 return g.apply(void 0, arguments)
11849 }, t.getStandardBidderAdServerTargeting = b
11850}), (function(e, t) {
11851 "use strict";
11852
11853 function n(e, t) {
11854 var n = 0;
11855 return n = parseFloat(e), isNaN(n) && (n = ""), {
11856 low: "" === n ? "" : r(e, s),
11857 med: "" === n ? "" : r(e, d),
11858 high: "" === n ? "" : r(e, u),
11859 auto: "" === n ? "" : r(e, l),
11860 dense: "" === n ? "" : r(e, c),
11861 custom: "" === n ? "" : r(e, t)
11862 }
11863 }
11864
11865 function r(e, t) {
11866 var n = "";
11867 if (!i(t)) return n;
11868 var r = t.buckets.reduce((function(e, t) {
11869 return e.max > t.max ? e : t
11870 }), {
11871 max: 0
11872 }),
11873 s = t.buckets.find((function(t) {
11874 if (e > r.max) {
11875 var i = t.precision || a;
11876 n = t.max.toFixed(i)
11877 } else if (e <= t.max && e >= t.min) return t
11878 }));
11879 return s && (n = o(e, s.increment, s.precision)), n
11880 }
11881
11882 function i(e) {
11883 if (!e || !e.buckets || !Array.isArray(e.buckets)) return !1;
11884 var t = !0;
11885 return e.buckets.forEach((function(e) {
11886 "undefined" != typeof e.min && e.max && e.increment || (t = !1)
11887 })), t
11888 }
11889
11890 function o(e, t, n) {
11891 n || (n = a);
11892 var r = 1 / t;
11893 return (Math.floor(e * r) / r).toFixed(n)
11894 }
11895 Object.defineProperty(t, "__esModule", {
11896 value: !0
11897 });
11898 var a = 2,
11899 s = {
11900 buckets: [{
11901 min: 0,
11902 max: 5,
11903 increment: .5
11904 }]
11905 },
11906 d = {
11907 buckets: [{
11908 min: 0,
11909 max: 20,
11910 increment: .1
11911 }]
11912 },
11913 u = {
11914 buckets: [{
11915 min: 0,
11916 max: 20,
11917 increment: .01
11918 }]
11919 },
11920 c = {
11921 buckets: [{
11922 min: 0,
11923 max: 3,
11924 increment: .01
11925 }, {
11926 min: 3,
11927 max: 8,
11928 increment: .05
11929 }, {
11930 min: 8,
11931 max: 20,
11932 increment: .5
11933 }]
11934 },
11935 l = {
11936 buckets: [{
11937 min: 0,
11938 max: 5,
11939 increment: .05
11940 }, {
11941 min: 5,
11942 max: 10,
11943 increment: .1
11944 }, {
11945 min: 10,
11946 max: 20,
11947 increment: .5
11948 }]
11949 };
11950 t.getPriceBucketString = n, t.isValidePriceConfig = i
11951}), (function(e, t, n) {
11952 "use strict";
11953
11954 function r(e, t) {
11955 function n() {
11956 switch (o) {
11957 case 0:
11958 return "Pending";
11959 case 1:
11960 return "Bid available";
11961 case 2:
11962 return "Bid returned empty or error response";
11963 case 3:
11964 return "Bid timed out"
11965 }
11966 }
11967 var r = t && t.bidId || i.getUniqueIdentifierStr(),
11968 o = e || 0;
11969 this.bidderCode = "", this.width = 0, this.height = 0, this.statusMessage = n(), this.adId = r, this.getStatusCode = function() {
11970 return o
11971 }, this.getSize = function() {
11972 return this.width + "x" + this.height
11973 }
11974 }
11975 var i = n(2);
11976 t.createBid = function() {
11977 return new(Function.prototype.bind.apply(r, [null].concat(Array.prototype.slice.call(arguments))))
11978 }
11979}), (function(e, t) {
11980 "use strict";
11981
11982 function n(e) {
11983 function t(e) {
11984 i = e
11985 }
11986
11987 function n() {
11988 return i
11989 }
11990
11991 function r() {}
11992 var i = e;
11993 return {
11994 callBids: r,
11995 setBidderCode: t,
11996 getBidderCode: n
11997 }
11998 }
11999 t.createNew = function(e) {
12000 return new n(e)
12001 }
12002}), (function(e, t, n) {
12003 "use strict";
12004 var r = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
12005 return typeof e
12006 } : function(e) {
12007 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
12008 },
12009 i = n(2),
12010 o = n(14),
12011 a = n(12),
12012 s = n(11),
12013 d = "INDEXEXCHANGE",
12014 u = "indexExchange",
12015 c = {
12016 INDEX_DEBUG_MODE: {
12017 queryParam: "pbjs_ix_debug",
12018 mode: {
12019 sandbox: {
12020 topFrameLimit: 10,
12021 queryValue: "sandbox",
12022 siteID: "999990"
12023 }
12024 }
12025 }
12026 },
12027 l = "IOM",
12028 f = "IPM";
12029 window.cygnus_index_parse_res = function(e) {
12030 try {
12031 if (e) {
12032 if ("object" !== ("undefined" == typeof _IndexRequestData ? "undefined" : r(_IndexRequestData)) || "object" !== r(_IndexRequestData.impIDToSlotID) || "undefined" == typeof _IndexRequestData.impIDToSlotID[e.id]) return;
12033 var t, n = 1;
12034 "object" === r(_IndexRequestData.reqOptions) && "object" === r(_IndexRequestData.reqOptions[e.id]) && ("function" == typeof _IndexRequestData.reqOptions[e.id].callback && (t = _IndexRequestData.reqOptions[e.id].callback), "number" == typeof _IndexRequestData.reqOptions[e.id].targetMode && (n = _IndexRequestData.reqOptions[e.id].targetMode)), _IndexRequestData.lastRequestID = e.id, _IndexRequestData.targetIDToBid = {}, _IndexRequestData.targetIDToResp = {}, _IndexRequestData.targetIDToCreative = {};
12035 for (var i = [], o = "undefined" == typeof e.seatbid ? 0 : e.seatbid.length, a = 0; o > a; a++)
12036 for (var s = 0; s < e.seatbid[a].bid.length; s++) {
12037 var d = e.seatbid[a].bid[s];
12038 if ("object" === r(d.ext) && "string" == typeof d.ext.pricelevel && "undefined" != typeof _IndexRequestData.impIDToSlotID[e.id][d.impid]) {
12039 var u, c, p, g = _IndexRequestData.impIDToSlotID[e.id][d.impid];
12040 "string" == typeof d.ext.dealid ? (u = 1 === n ? g + d.ext.pricelevel : g + "_" + d.ext.dealid, c = g + "_" + d.ext.dealid, p = f + "_") : (u = g + d.ext.pricelevel, c = g + d.ext.pricelevel, p = l + "_"), void 0 === _IndexRequestData.targetIDToBid[u] ? _IndexRequestData.targetIDToBid[u] = [d.adm] : _IndexRequestData.targetIDToBid[u].push(d.adm), void 0 === _IndexRequestData.targetIDToCreative[c] ? _IndexRequestData.targetIDToCreative[c] = [d.adm] : _IndexRequestData.targetIDToCreative[c].push(d.adm);
12041 var m = {};
12042 m.impressionID = d.impid, "undefined" != typeof d.ext.dealid && (m.dealID = d.ext.dealid), m.bid = d.price, m.slotID = g, m.priceLevel = d.ext.pricelevel, m.target = p + u, _IndexRequestData.targetIDToResp[u] = m, i.push(m)
12043 }
12044 }
12045 "function" == typeof t && (0 === i.length ? t(e.id) : t(e.id, i))
12046 }
12047 } catch (b) {}
12048 "function" == typeof window.cygnus_index_ready_state && window.cygnus_index_ready_state()
12049 }, window.index_render = function(e, t) {
12050 try {
12051 var n = _IndexRequestData.targetIDToCreative[t].pop();
12052 if (null != n) e.write(n);
12053 else {
12054 var r = "https:" === window.location.protocol ? "https://as-sec.casalemedia.com" : "http://as.casalemedia.com";
12055 r += "/headerstats?type=RT&s=" + cygnus_index_args.siteID + "&u=" + encodeURIComponent(location.href) + "&r=" + _IndexRequestData.lastRequestID;
12056 var i = new Image;
12057 i.src = r + "&blank=" + t
12058 }
12059 } catch (o) {}
12060 }, window.headertag_render = function(e, t, n) {
12061 for (var r = n, i = t.split(","), o = 0; o < i.length; o++) {
12062 var a = i[o].split("_");
12063 if (a[0] == r) return index_render(e, i[o]), void 0
12064 }
12065 }, window.cygnus_index_args = {};
12066 var p = [
12067 [728, 90],
12068 [120, 600],
12069 [300, 250],
12070 [160, 600],
12071 [336, 280],
12072 [234, 60],
12073 [300, 600],
12074 [300, 50],
12075 [320, 50],
12076 [970, 250],
12077 [300, 1050],
12078 [970, 90],
12079 [180, 150]
12080 ],
12081 g = function() {
12082 return m(c.INDEX_DEBUG_MODE.queryParam).toUpperCase()
12083 },
12084 m = function(e) {
12085 for (var t = window, n = "", r = 0; r < c.INDEX_DEBUG_MODE.mode.sandbox.topFrameLimit && t.parent != t; r++) {
12086 try {
12087 n = t.document.referrer
12088 } catch (i) {}
12089 t = t.parent
12090 }
12091 var o = top === self ? location.href : n,
12092 a = "[\\?&]" + e + "=([^&#]*)",
12093 s = new RegExp(a),
12094 d = s.exec(o);
12095 return null === d ? "" : decodeURIComponent(d[1].replace(/\+/g, " "))
12096 },
12097 b = function() {
12098 function e(e) {
12099 var t = o[e];
12100 return "string" == typeof t ? t : "\\u" + ("0000" + e.charCodeAt(0).toString(16)).slice(-4)
12101 }
12102
12103 function t(t) {
12104 return r.lastIndex = 0, r.test(t) ? t.replace(r, e) : t
12105 }
12106
12107 function n(e, t, n) {
12108 if (this.initialized = !1, "number" != typeof e || e % 1 !== 0 || 0 > e) throw "Invalid Site ID";
12109 if (n = Number(n), "number" == typeof n && n % 1 === 0 && n >= 0 && (this.timeoutDelay = n), this.siteID = e, this.impressions = [], this._parseFnName = void 0, top === self ? (this.sitePage = location.href, this.topframe = 1) : (this.sitePage = document.referrer, this.topframe = 0), "undefined" != typeof t) {
12110 if ("function" != typeof t) throw "Invalid jsonp target function";
12111 this._parseFnName = "cygnus_index_args.parseFn"
12112 }
12113 _IndexRequestData.requestCounter = "undefined" == typeof _IndexRequestData.requestCounter ? Math.floor(256 * Math.random()) : (_IndexRequestData.requestCounter + 1) % 256, this.requestID = String((new Date).getTime() % 2592e3 * 256 + _IndexRequestData.requestCounter + 256), this.initialized = !0
12114 }
12115 window.cygnus_index_args.parseFn = cygnus_index_parse_res;
12116 var r = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
12117 o = {
12118 "\b": "\\b",
12119 " ": "\\t",
12120 "\n": "\\n",
12121 "\f": "\\f",
12122 "\r": "\\r",
12123 '"': '\\"',
12124 "\\": "\\\\"
12125 };
12126 n.prototype.serialize = function() {
12127 var e = '{"id":"' + this.requestID + '","site":{"page":"' + t(this.sitePage) + '"';
12128 "string" == typeof document.referrer && "" !== document.referrer && (e += ',"ref":"' + t(document.referrer) + '"'), e += '},"imp":[';
12129 for (var n = 0; n < this.impressions.length; n++) {
12130 var r = this.impressions[n],
12131 i = [];
12132 e += '{"id":"' + r.id + '", "banner":{"w":' + r.w + ',"h":' + r.h + ',"topframe":' + String(this.topframe) + "}", "number" == typeof r.bidfloor && (e += ',"bidfloor":' + r.bidfloor, "string" == typeof r.bidfloorcur && (e += ',"bidfloorcur":"' + t(r.bidfloorcur) + '"')), "string" != typeof r.slotID || r.slotID.match(/^\s*$/) || i.push('"sid":"' + t(r.slotID) + '"'), "number" == typeof r.siteID && i.push('"siteID":' + r.siteID), i.length > 0 && (e += ',"ext": {' + i.join() + "}"), e += n + 1 === this.impressions.length ? "}" : "},"
12133 }
12134 return e += "]}"
12135 }, n.prototype.setPageOverride = function(e) {
12136 return "string" != typeof e || e.match(/^\s*$/) ? !1 : (this.sitePage = e, !0)
12137 }, n.prototype.addImpression = function(e, t, n, r, i, o) {
12138 var a = {
12139 id: String(this.impressions.length + 1)
12140 };
12141 if ("number" != typeof e || 1 >= e) return null;
12142 if ("number" != typeof t || 1 >= t) return null;
12143 if (("string" == typeof i || "number" == typeof i) && String(i).length <= 50 && (a.slotID = String(i)), a.w = e, a.h = t, void 0 !== n && "number" != typeof n) return null;
12144 if ("number" == typeof n) {
12145 if (0 > n) return null;
12146 if (a.bidfloor = n, void 0 !== r && "string" != typeof r) return null;
12147 a.bidfloorcur = r
12148 }
12149 if ("undefined" != typeof o) {
12150 if (!("number" == typeof o && o % 1 === 0 && o >= 0)) return null;
12151 a.siteID = o
12152 }
12153 return this.impressions.push(a), a.id
12154 }, n.prototype.buildRequest = function() {
12155 if (0 !== this.impressions.length && this.initialized === !0) {
12156 var e, t = encodeURIComponent(this.serialize());
12157 g() == c.INDEX_DEBUG_MODE.mode.sandbox.queryValue.toUpperCase() ? (this.siteID = c.INDEX_DEBUG_MODE.mode.sandbox.siteID, e = "https:" === window.location.protocol ? "https://sandbox.ht.indexexchange.com" : "http://sandbox.ht.indexexchange.com", i.logMessage("IX DEBUG: Sandbox mode activated")) : e = "https:" === window.location.protocol ? "https://as-sec.casalemedia.com" : "http://as.casalemedia.com";
12158 var n = encodeURIComponent("0.24.1");
12159 return e += "/cygnus?v=7&fn=cygnus_index_parse_res&s=" + this.siteID + "&r=" + t + "&pid=pb" + n, "number" == typeof this.timeoutDelay && this.timeoutDelay % 1 === 0 && this.timeoutDelay >= 0 && (e += "&t=" + this.timeoutDelay), e
12160 }
12161 };
12162 try {
12163 if ("undefined" == typeof cygnus_index_args || "undefined" == typeof cygnus_index_args.siteID || "undefined" == typeof cygnus_index_args.slots) return;
12164 var a = new n(cygnus_index_args.siteID, cygnus_index_args.parseFn, cygnus_index_args.timeout);
12165 cygnus_index_args.url && "string" == typeof cygnus_index_args.url && a.setPageOverride(cygnus_index_args.url), _IndexRequestData.impIDToSlotID[a.requestID] = {}, _IndexRequestData.reqOptions[a.requestID] = {};
12166 for (var s, u, l = 0; l < cygnus_index_args.slots.length; l++) s = cygnus_index_args.slots[l], u = a.addImpression(s.width, s.height, s.bidfloor, s.bidfloorcur, s.id, s.siteID), u && (_IndexRequestData.impIDToSlotID[a.requestID][u] = String(s.id));
12167 return "number" == typeof cygnus_index_args.targetMode && (_IndexRequestData.reqOptions[a.requestID].targetMode = cygnus_index_args.targetMode), "function" == typeof cygnus_index_args.callback && (_IndexRequestData.reqOptions[a.requestID].callback = cygnus_index_args.callback), a.buildRequest()
12168 } catch (f) {
12169 i.logError("Error calling index adapter", d, f)
12170 }
12171 },
12172 v = function() {
12173 function e(e) {
12174 var m = e.bids;
12175 if ("undefined" == typeof window._IndexRequestData && (window._IndexRequestData = {}, window._IndexRequestData.impIDToSlotID = {}, window._IndexRequestData.reqOptions = {}), _IndexRequestData.targetAggregate = {
12176 open: {},
12177 "private": {}
12178 }, i.hasValidBidRequest(m[0].params, f, d)) {
12179 cygnus_index_args.slots = [];
12180 for (var v = 0, y = 0; y < m.length; y++) {
12181 var h = m[y],
12182 _ = 0;
12183 v++, h.sizes[0] instanceof Array || (h.sizes = [h.sizes]);
12184 for (var I = 0; I < h.sizes.length; I++) {
12185 for (var w = !1, T = 0; T < p.length; T++)
12186 if (h.sizes[I][0] == p[T][0] && h.sizes[I][1] == p[T][1]) {
12187 h.sizes[I][0] = Number(h.sizes[I][0]), h.sizes[I][1] = Number(h.sizes[I][1]), w = !0;
12188 break
12189 }
12190 if (w) {
12191 var E = !1;
12192 if (h.params.size && h.params.size instanceof Array) {
12193 if (h.sizes[I][0] != h.params.size[0] || h.sizes[I][1] != h.params.size[1]) continue;
12194 E = !0
12195 }
12196 h.params.timeout && "undefined" == typeof cygnus_index_args.timeout && (cygnus_index_args.timeout = h.params.timeout);
12197 var S = Number(h.params.siteID);
12198 if ("number" != typeof S || S % 1 != 0 || 0 >= S) i.logMessage(d + " slot excluded from request due to invalid siteID");
12199 else if (S && "undefined" == typeof cygnus_index_args.siteID && (cygnus_index_args.siteID = S), i.hasValidBidRequest(h.params, f, d)) {
12200 g = h.placementCode;
12201 var x = h.params[f[0]];
12202 if ("string" != typeof x && "number" != typeof x) {
12203 i.logError(d + " bid contains invalid slot ID from " + h.placementCode + ". Discarding slot");
12204 continue
12205 }
12206 _++;
12207 var A = {
12208 width: h.sizes[I][0],
12209 height: h.sizes[I][1]
12210 },
12211 D = E ? String(x) : x + "_" + _;
12212 if (l[D] = h, cygnus_index_args.slots = t({
12213 id: D,
12214 width: A.width,
12215 height: A.height,
12216 siteID: S || cygnus_index_args.siteID
12217 }, cygnus_index_args.slots), h.params.tier2SiteID) {
12218 var B = Number(h.params.tier2SiteID);
12219 if ("undefined" != typeof B && !B) continue;
12220 cygnus_index_args.slots = t({
12221 id: "T1_" + D,
12222 width: A.width,
12223 height: A.height,
12224 siteID: B
12225 }, cygnus_index_args.slots)
12226 }
12227 if (h.params.tier3SiteID) {
12228 var R = Number(h.params.tier3SiteID);
12229 if ("undefined" != typeof R && !R) continue;
12230 cygnus_index_args.slots = t({
12231 id: "T2_" + D,
12232 width: A.width,
12233 height: A.height,
12234 siteID: R
12235 }, cygnus_index_args.slots)
12236 }
12237 }
12238 } else i.logMessage(d + " slot excluded from request due to no valid sizes")
12239 }
12240 }
12241 cygnus_index_args.slots.length > 20 && i.logError("Too many unique sizes on slots, will use the first 20.", d), s.loadScript(b());
12242 var C = !1;
12243 window.cygnus_index_ready_state = function() {
12244 if (!C) {
12245 C = !0;
12246 try {
12247 var e = _IndexRequestData.targetIDToBid;
12248 for (var t in l) {
12249 var s = l[t],
12250 f = s.placementCode,
12251 p = [];
12252 for (var g in e) {
12253 var m = /^(T\d_)?(.+)_(\d+)$/.exec(g);
12254 if (m) {
12255 var b = m[1] || "",
12256 v = m[2],
12257 y = m[3],
12258 h = n(cygnus_index_args, b + v);
12259 if (v === t) {
12260 var _ = o.createBid(1);
12261 _.cpm = y / 100, _.ad = e[g][0], _.bidderCode = u, _.width = h.width, _.height = h.height, _.siteID = h.siteID, "object" === r(_IndexRequestData.targetIDToResp) && "object" === r(_IndexRequestData.targetIDToResp[g]) && "undefined" != typeof _IndexRequestData.targetIDToResp[g].dealID ? ("undefined" == typeof _IndexRequestData.targetAggregate["private"][f] && (_IndexRequestData.targetAggregate["private"][f] = []), _.dealId = _IndexRequestData.targetIDToResp[g].dealID, _IndexRequestData.targetAggregate["private"][f].push(v + "_" + _IndexRequestData.targetIDToResp[g].dealID)) : ("undefined" == typeof _IndexRequestData.targetAggregate.open[f] && (_IndexRequestData.targetAggregate.open[f] = []), _IndexRequestData.targetAggregate.open[f].push(v + "_" + y)), p.push(_)
12262 }
12263 } else i.logError("Unable to parse " + g + ", skipping slot", d)
12264 }
12265 var I;
12266 if (p.length > 0)
12267 for (var w = 0; w < p.length; w++) a.addBidResponse(f, p[w]);
12268 else {
12269 var _ = o.createBid(2);
12270 _.bidderCode = u, I = _, a.addBidResponse(f, I)
12271 }
12272 }
12273 } catch (T) {
12274 i.logError("Error calling index adapter", d, T), c()
12275 } finally {
12276 _IndexRequestData.targetIDToBid = {}
12277 }
12278 l = {}
12279 }
12280 }
12281 }
12282 }
12283
12284 function t(e, t) {
12285 for (var n = 0; n < t.length; n++)
12286 if (e.id === t[n].id) return t;
12287 return t.push(e), t
12288 }
12289
12290 function n(e, t) {
12291 var n = e.slots,
12292 r = {};
12293 return i._each(n, (function(e) {
12294 e.id === t && (r = e)
12295 })), r
12296 }
12297
12298 function c() {
12299 var e = o.createBid(2);
12300 e.bidderCode = u, a.addBidResponse(g, e)
12301 }
12302 var l = {},
12303 f = ["id", "siteID"],
12304 g = "";
12305 return {
12306 callBids: e
12307 }
12308 };
12309 e.exports = v
12310}), (function(e, t, n) {
12311 "use strict";
12312 var r = n(2),
12313 i = n(14),
12314 o = n(12),
12315 a = function() {
12316 function e(e) {
12317 a = e.bids, d = [];
12318 for (var n = 0; n < a.length; n++) {
12319 var r = a[n];
12320 s = s || r.params.publisherId, d.push(r.params.adSlot)
12321 }
12322 t()
12323 }
12324
12325 function t() {
12326 u = r.createInvisibleIframe();
12327 var e = document.getElementsByTagName("head")[0];
12328 e.insertBefore(u, e.firstChild);
12329 var t = r.getIframeDocument(u);
12330 t.write(n()), t.close()
12331 }
12332
12333 function n() {
12334 var e = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><base target="_top" /><script>inDapIF=true;</script></head>';
12335 e += "<body>", e += "<script>", e += 'window.pm_pub_id = "%%PM_PUB_ID%%";window.pm_optimize_adslots = [%%PM_OPTIMIZE_ADSLOTS%%];window.pm_async_callback_fn = "window.parent.pbjs.handlePubmaticCallback";', e += "</script>";
12336 var t = {};
12337 return t.PM_PUB_ID = s, t.PM_OPTIMIZE_ADSLOTS = d.map((function(e) {
12338 return "'" + e + "'"
12339 })).join(","), e += '<script src="https://ads.pubmatic.com/AdServer/js/gshowad.js"></script>', e += "<script>", e += "</script>", e += "</body></html>", e = r.replaceTokenInString(e, t, "%%")
12340 }
12341 var a, s, d = [],
12342 u = void 0;
12343 return pbjs.handlePubmaticCallback = function() {
12344 var e = {},
12345 t = {};
12346 try {
12347 e = u.contentWindow.bidDetailsMap, t = u.contentWindow.progKeyValueMap
12348 } catch (n) {
12349 r.logError(n, "Error parsing Pubmatic response")
12350 }
12351 var s, d, c, l, f, p = e || {},
12352 g = t || {};
12353 for (s = 0; s < a.length; s++) {
12354 var m;
12355 l = a[s].params, d = p[l.adSlot] || {}, g[l.adSlot] && -1 === g[l.adSlot].indexOf("=") && (g[l.adSlot] = g[l.adSlot].replace(/([a-z]+);(.[^;]*)/gi, "$1=$2")), c = (g[l.adSlot] || "").split(";").reduce((function(e, t) {
12356 var n = t.split("=");
12357 return e[n[0]] = n[1], e
12358 }), {}), "1" === c.bidstatus ? (f = c.bidid.split("@")[1].split("x"), m = i.createBid(1), m.bidderCode = "pubmatic", m.adSlot = l.adSlot, m.cpm = Number(c.bid), m.ad = unescape(d.creative_tag), m.ad += r.createTrackPixelIframeHtml(decodeURIComponent(d.tracking_url)), m.width = f[0], m.height = f[1], m.dealId = c.wdeal, o.addBidResponse(a[s].placementCode, m)) : (m = i.createBid(2), m.bidderCode = "pubmatic", o.addBidResponse(a[s].placementCode, m))
12359 }
12360 }, {
12361 callBids: e
12362 }
12363 };
12364 e.exports = a
12365}), (function(e, t, n) {
12366 "use strict";
12367
12368 function r(e) {
12369 return e && e.__esModule ? e : {
12370 "default": e
12371 }
12372 }
12373
12374 function i(e) {
12375 if (e && e.__esModule) return e;
12376 var t = {};
12377 if (null != e)
12378 for (var n in e) Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
12379 return t["default"] = e, t
12380 }
12381
12382 function o() {
12383 return "pbjs_lite_" + pbjs.version
12384 }
12385
12386 function a() {
12387 return "https:" === location.protocol
12388 }
12389
12390 function s() {
12391 function e(e) {
12392 var t = e.bids || [];
12393 t.forEach((function(t) {
12394 function n(e) {
12395 try {
12396 y.logMessage("XHR callback function called for ad ID: " + t.bidId), l(e, t)
12397 } catch (n) {
12398 "string" == typeof n ? y.logWarn(n + " when processing rubicon response for placement code " + t.placementCode) : y.logError("Error processing rubicon response for placement code " + t.placementCode, null, n), a()
12399 }
12400 }
12401
12402 function o(e, t) {
12403 y.logError("Request for rubicon responded with:", t.status, e), a()
12404 }
12405
12406 function a() {
12407 var e = g["default"].createBid(_.STATUS.NO_BID, t);
12408 e.bidderCode = t.bidder, b["default"].addBidResponse(t.placementCode, e)
12409 }
12410 try {
12411 "video" === t.mediaType ? h.ajax(T, {
12412 success: n,
12413 error: o
12414 }, r(t, e), {
12415 withCredentials: !0
12416 }) : h.ajax(i(t), {
12417 success: n,
12418 error: o
12419 }, void 0, {
12420 withCredentials: !0
12421 })
12422 } catch (s) {
12423 y.logError("Error sending rubicon request for placement code " + t.placementCode, null, s), a()
12424 }
12425 }))
12426 }
12427
12428 function t() {
12429 return [window.screen.width, window.screen.height].join("x")
12430 }
12431
12432 function n() {
12433 function e() {
12434 var e = window.DigiTrust && window.DigiTrust.getUser({
12435 member: "T9QSFKPDN9"
12436 });
12437 return e && e.success && e.identity || null
12438 }
12439 var t = e();
12440 return !t || t.privacy && t.privacy.optout ? [] : ["dt.id", t.id, "dt.keyv", t.keyv]
12441 }
12442
12443 function r(e, n) {
12444 e.startTime = (new Date).getTime();
12445 var r = e.params;
12446 if (!r || "object" !== c(r.video)) throw "Invalid Video Bid";
12447 var i = void 0;
12448 if (r.video.playerWidth && r.video.playerHeight) i = [r.video.playerWidth, r.video.playerHeight];
12449 else {
12450 if (!(Array.isArray(e.sizes) && e.sizes.length > 0 && Array.isArray(e.sizes[0]) && e.sizes[0].length > 1)) throw "Invalid Video Bid - No size provided";
12451 i = e.sizes[0]
12452 }
12453 var a = {
12454 page_url: r.referrer ? r.referrer : y.getTopWindowUrl(),
12455 resolution: t(),
12456 account_id: r.accountId,
12457 integration: o(),
12458 timeout: n.timeout - (Date.now() - n.auctionStart + E),
12459 stash_creatives: !0,
12460 ae_pass_through_parameters: r.video.aeParams,
12461 slots: []
12462 },
12463 s = {
12464 site_id: r.siteId,
12465 zone_id: r.zoneId,
12466 position: r.position || "btf",
12467 floor: parseFloat(r.floor) > .01 ? r.floor : .01,
12468 element_id: e.placementCode,
12469 name: e.placementCode,
12470 language: r.video.language,
12471 width: i[0],
12472 height: i[1]
12473 };
12474 if (!r.video.size_id) throw "Invalid Video Bid - Invalid Ad Type!";
12475 return s.size_id = r.video.size_id, r.inventory && "object" === c(r.inventory) && (s.inventory = r.inventory), r.keywords && Array.isArray(r.keywords) && (s.keywords = r.keywords), r.visitor && "object" === c(r.visitor) && (s.visitor = r.visitor), a.slots.push(s), JSON.stringify(a)
12476 }
12477
12478 function i(e) {
12479 e.startTime = (new Date).getTime();
12480 var r = e.params,
12481 i = r.accountId,
12482 d = r.siteId,
12483 u = r.zoneId,
12484 l = r.position,
12485 f = r.floor,
12486 p = r.keywords,
12487 g = r.visitor,
12488 m = r.inventory,
12489 b = r.userId,
12490 v = r.referrer;
12491 f = (f = parseFloat(f)) > .01 ? f : .01, l = l || "btf";
12492 var h = s.masSizeOrdering(Array.isArray(e.params.sizes) ? e.params.sizes.map((function(e) {
12493 return (S[e] || "").split("x")
12494 })) : e.sizes);
12495 if (h.length < 1) throw "no valid sizes";
12496 if (!/^\d+$/.test(i)) throw "invalid accountId provided";
12497 var _ = ["account_id", i, "site_id", d, "zone_id", u, "size_id", h[0], "alt_size_ids", h.slice(1).join(",") || void 0, "p_pos", l, "rp_floor", f, "rp_secure", a() ? "1" : "0", "tk_flint", o(), "p_screen_res", t(), "kw", p, "tk_user_key", b];
12498 return null !== g && "object" === ("undefined" == typeof g ? "undefined" : c(g)) && y._each(g, (function(e, t) {
12499 return _.push("tg_v." + t, e)
12500 })), null !== m && "object" === ("undefined" == typeof m ? "undefined" : c(m)) && y._each(m, (function(e, t) {
12501 return _.push("tg_i." + t, e)
12502 })), _.push("rand", Math.random(), "rf", v ? v : y.getTopWindowUrl()), _ = _.concat(n()), _.reduce((function(e, t, n) {
12503 return n % 2 === 0 && void 0 !== _[n + 1] ? e + t + "=" + encodeURIComponent(_[n + 1]) + "&" : e
12504 }), w + "?").slice(0, -1)
12505 }
12506
12507 function l(e, t) {
12508 var n = JSON.parse(e),
12509 r = n.ads,
12510 i = t.placementCode;
12511 if ("object" !== ("undefined" == typeof n ? "undefined" : c(n)) || "ok" !== n.status) throw "bad response";
12512 if ("video" === t.mediaType && "object" === ("undefined" == typeof r ? "undefined" : c(r)) && (r = r[i]), !Array.isArray(r) || r.length < 1) throw "invalid ad response";
12513 r = r.sort(p), r.forEach((function(e) {
12514 if ("ok" !== e.status) throw "bad ad status";
12515 var n = g["default"].createBid(_.STATUS.GOOD, t);
12516 if (n.creative_id = e.ad_id, n.bidderCode = t.bidder, n.cpm = e.cpm || 0, n.dealId = e.deal, "video" === t.mediaType) n.width = t.params.video.playerWidth, n.height = t.params.video.playerHeight, n.vastUrl = e.creative_depot_url, n.descriptionUrl = e.impression_id, n.impression_id = e.impression_id;
12517 else {
12518 n.ad = m(e.script, e.impression_id);
12519 var r = S[e.size_id].split("x").map((function(e) {
12520 return Number(e)
12521 })),
12522 i = u(r, 2);
12523 n.width = i[0], n.height = i[1]
12524 }
12525 n.rubiconTargeting = (Array.isArray(e.targeting) ? e.targeting : []).reduce((function(e, t) {
12526 return e[t.key] = t.values[0], e
12527 }), {
12528 rpfl_elemid: t.placementCode
12529 });
12530 try {
12531 b["default"].addBidResponse(t.placementCode, n)
12532 } catch (o) {
12533 y.logError("Error from addBidResponse", null, o)
12534 }
12535 }))
12536 }
12537
12538 function p(e, t) {
12539 return (t.cpm || 0) - (e.cpm || 0)
12540 }
12541 var m = function(e, t) {
12542 return "<html>\n<head><script type='text/javascript'>inDapIF=true;</script></head>\n<body style='margin : 0; padding: 0;'>\n<!-- Rubicon Project Ad Tag -->\n<div data-rp-impression-id='" + t + "'>\n<script type='text/javascript'>" + e + "</script>\n</div>\n</body>\n</html>"
12543 };
12544 return d(f.createNew(I), {
12545 callBids: e,
12546 createNew: s.createNew
12547 })
12548 }
12549 var d = Object.assign || function(e) {
12550 for (var t = 1; t < arguments.length; t++) {
12551 var n = arguments[t];
12552 for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
12553 }
12554 return e
12555 },
12556 u = (function() {
12557 function e(e, t) {
12558 var n = [],
12559 r = !0,
12560 i = !1,
12561 o = void 0;
12562 try {
12563 for (var a, s = e[Symbol.iterator](); !(r = (a = s.next()).done) && (n.push(a.value), !t || n.length !== t); r = !0);
12564 } catch (d) {
12565 i = !0, o = d
12566 } finally {
12567 try {
12568 !r && s["return"] && s["return"]()
12569 } finally {
12570 if (i) throw o
12571 }
12572 }
12573 return n
12574 }
12575 return function(t, n) {
12576 if (Array.isArray(t)) return t;
12577 if (Symbol.iterator in Object(t)) return e(t, n);
12578 throw new TypeError("Invalid attempt to destructure non-iterable instance")
12579 }
12580 })(),
12581 c = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
12582 return typeof e
12583 } : function(e) {
12584 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
12585 },
12586 l = n(15),
12587 f = i(l),
12588 p = n(14),
12589 g = r(p),
12590 m = n(12),
12591 b = r(m),
12592 v = n(2),
12593 y = i(v),
12594 h = n(19),
12595 _ = n(3),
12596 I = "rubicon",
12597 w = "//fastlane.rubiconproject.com/a/api/fastlane.json",
12598 T = "//fastlane-adv.rubiconproject.com/v1/auction/video",
12599 E = 500,
12600 S = {
12601 1: "468x60",
12602 2: "728x90",
12603 8: "120x600",
12604 9: "160x600",
12605 10: "300x600",
12606 15: "300x250",
12607 16: "336x280",
12608 19: "300x100",
12609 31: "980x120",
12610 32: "250x360",
12611 33: "180x500",
12612 35: "980x150",
12613 37: "468x400",
12614 38: "930x180",
12615 43: "320x50",
12616 44: "300x50",
12617 48: "300x300",
12618 54: "300x1050",
12619 55: "970x90",
12620 57: "970x250",
12621 58: "1000x90",
12622 59: "320x80",
12623 61: "1000x1000",
12624 65: "640x480",
12625 67: "320x480",
12626 68: "1800x1000",
12627 72: "320x320",
12628 73: "320x160",
12629 78: "980x240",
12630 79: "980x300",
12631 80: "980x400",
12632 83: "480x300",
12633 94: "970x310",
12634 96: "970x210",
12635 101: "480x320",
12636 102: "768x1024",
12637 103: "480x280",
12638 113: "1000x300",
12639 117: "320x100",
12640 125: "800x250",
12641 126: "200x600"
12642 };
12643 y._each(S, (function(e, t) {
12644 return S[e] = t
12645 })), s.masSizeOrdering = function(e) {
12646 var t = [15, 2, 9];
12647 return y.parseSizesInput(e).reduce((function(e, t) {
12648 var n = parseInt(S[t], 10);
12649 return n && e.push(n), e
12650 }), []).sort((function(e, n) {
12651 var r = t.indexOf(e),
12652 i = t.indexOf(n);
12653 return r > -1 || i > -1 ? -1 === r ? 1 : -1 === i ? -1 : r - i : e - n
12654 }))
12655 }, s.createNew = function() {
12656 return new s
12657 }, e.exports = s
12658}), (function(e, t, n) {
12659 "use strict";
12660
12661 function r(e) {
12662 c = e
12663 }
12664
12665 function i(e, t, n) {
12666 var r = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : {};
12667 try {
12668 var i = void 0,
12669 l = !1,
12670 f = r.method || (n ? "POST" : "GET"),
12671 p = "object" === ("undefined" == typeof t ? "undefined" : a(t)) ? t : {
12672 success: function() {
12673 d.logMessage("xhr success")
12674 },
12675 error: function(e) {
12676 d.logError("xhr error", null, e)
12677 }
12678 };
12679 if ("function" == typeof t && (p.success = t), window.XMLHttpRequest ? (i = new window.XMLHttpRequest, void 0 === i.responseType && (l = !0)) : l = !0, i.timeout = c, l ? (i = new window.XDomainRequest, i.onload = function() {
12680 p.success(i.responseText, i)
12681 }, i.onerror = function() {
12682 p.error("error", i)
12683 }, i.ontimeout = function() {
12684 p.error("timeout", i)
12685 }, i.onprogress = function() {
12686 d.logMessage("xhr onprogress")
12687 }) : i.onreadystatechange = function() {
12688 if (i.readyState === u) {
12689 var e = i.status;
12690 e >= 200 && 300 > e || 304 === e ? p.success(i.responseText, i) : p.error(i.statusText, i)
12691 }
12692 }, "GET" === f && n) {
12693 var g = s.parse(e);
12694 o(g.search, n), e = s.format(g)
12695 }
12696 i.open(f, e), l || (r.withCredentials && (i.withCredentials = !0), d._each(r.customHeaders, (function(e, t) {
12697 i.setRequestHeader(t, e)
12698 })), r.preflight && i.setRequestHeader("X-Requested-With", "XMLHttpRequest"), i.setRequestHeader("Content-Type", r.contentType || "text/plain")), i.send("POST" === f && n)
12699 } catch (m) {
12700 d.logError("xhr construction", m)
12701 }
12702 }
12703 Object.defineProperty(t, "__esModule", {
12704 value: !0
12705 });
12706 var o = Object.assign || function(e) {
12707 for (var t = 1; t < arguments.length; t++) {
12708 var n = arguments[t];
12709 for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
12710 }
12711 return e
12712 },
12713 a = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
12714 return typeof e
12715 } : function(e) {
12716 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
12717 };
12718 t.setAjaxTimeout = r, t.ajax = i;
12719 var s = n(20),
12720 d = n(2),
12721 u = 4,
12722 c = 3e3
12723}), (function(e, t) {
12724 "use strict";
12725
12726 function n(e) {
12727 return e ? e.replace(/^\?/, "").split("&").reduce((function(e, t) {
12728 var n = t.split("="),
12729 r = a(n, 2),
12730 i = r[0],
12731 o = r[1];
12732 return /\[\]$/.test(i) ? (i = i.replace("[]", ""), e[i] = e[i] || [], e[i].push(o)) : e[i] = o || "", e
12733 }), {}) : {}
12734 }
12735
12736 function r(e) {
12737 return Object.keys(e).map((function(t) {
12738 return Array.isArray(e[t]) ? e[t].map((function(e) {
12739 return t + "[]=" + e
12740 })).join("&") : t + "=" + e[t]
12741 })).join("&")
12742 }
12743
12744 function i(e) {
12745 var t = document.createElement("a");
12746 return t.href = decodeURIComponent(e), {
12747 protocol: (t.protocol || "").replace(/:$/, ""),
12748 hostname: t.hostname,
12749 port: +t.port,
12750 pathname: t.pathname.replace(/^(?!\/)/, "/"),
12751 search: n(t.search || ""),
12752 hash: (t.hash || "").replace(/^#/, ""),
12753 host: t.host
12754 }
12755 }
12756
12757 function o(e) {
12758 return (e.protocol || "http") + "://" + (e.host || e.hostname + (e.port ? ":" + e.port : "")) + (e.pathname || "") + (e.search ? "?" + r(e.search || "") : "") + (e.hash ? "#" + e.hash : "")
12759 }
12760 Object.defineProperty(t, "__esModule", {
12761 value: !0
12762 });
12763 var a = (function() {
12764 function e(e, t) {
12765 var n = [],
12766 r = !0,
12767 i = !1,
12768 o = void 0;
12769 try {
12770 for (var a, s = e[Symbol.iterator](); !(r = (a = s.next()).done) && (n.push(a.value), !t || n.length !== t); r = !0);
12771 } catch (d) {
12772 i = !0, o = d
12773 } finally {
12774 try {
12775 !r && s["return"] && s["return"]()
12776 } finally {
12777 if (i) throw o
12778 }
12779 }
12780 return n
12781 }
12782 return function(t, n) {
12783 if (Array.isArray(t)) return t;
12784 if (Symbol.iterator in Object(t)) return e(t, n);
12785 throw new TypeError("Invalid attempt to destructure non-iterable instance")
12786 }
12787 })();
12788 t.parseQS = n, t.formatQS = r, t.parse = i, t.format = o
12789}), (function(e, t, n) {
12790 "use strict";
12791 var r = n(14),
12792 i = n(12),
12793 o = n(11),
12794 a = function() {
12795 function e(e) {
12796 !window.criteo_pubtag || window.criteo_pubtag instanceof Array ? (t(e), o.loadScript(c, (function() {}), !0)) : t(e)
12797 }
12798
12799 function t(e) {
12800 window.Criteo = window.Criteo || {}, window.Criteo.events = window.Criteo.events || [];
12801 var t = function() {
12802 for (var t = e.bids || [], n = [], r = !1, i = 0; i < t.length; i++) {
12803 var o = t[i];
12804 n.push(new Criteo.PubTag.DirectBidding.DirectBiddingSlot(o.placementCode, o.params.zoneId, void 0, o.transactionId)), r |= void 0 !== o.params.audit
12805 }
12806 var a = new Criteo.PubTag.DirectBidding.DirectBiddingEvent(f, new Criteo.PubTag.DirectBidding.DirectBiddingUrlBuilder(r), n, s(n), d(n), d(n));
12807 window.criteo_pubtag.push(a)
12808 };
12809 window.Criteo.events.push(t)
12810 }
12811
12812 function n(e) {
12813 try {
12814 return JSON.parse(e)
12815 } catch (t) {
12816 return {}
12817 }
12818 }
12819
12820 function a(e) {
12821 return void 0 === e.slots
12822 }
12823
12824 function s(e) {
12825 return function(t) {
12826 var o = n(t);
12827 if (a(o)) return d(e)();
12828 for (var s = 0; s < e.length; s++) {
12829 for (var c = null, f = 0; f < o.slots.length; f++)
12830 if (o.slots[f] && o.slots[f].impid === e[s].impId) {
12831 c = o.slots.splice(f, 1)[0];
12832 break
12833 }
12834 var p;
12835 c ? (p = r.createBid(1), p.bidderCode = l, p.cpm = c.cpm, p.ad = c.creative, p.width = c.width, p.height = c.height) : p = u(), i.addBidResponse(e[s].impId, p)
12836 }
12837 }
12838 }
12839
12840 function d(e) {
12841 return function() {
12842 for (var t = 0; t < e.length; t++) i.addBidResponse(e[t].impId, u())
12843 }
12844 }
12845
12846 function u() {
12847 var e = r.createBid(2);
12848 return e.bidderCode = l, e
12849 }
12850 var c = window.location.protocol + "//static.criteo.net/js/ld/publishertag.js",
12851 l = "criteo",
12852 f = 125;
12853 return {
12854 callBids: e
12855 }
12856 };
12857 e.exports = a
12858}), (function(e, t, n) {
12859 "use strict";
12860 n(23), n(56), n(61), Number.isInteger = Number.isInteger || function(e) {
12861 return "number" == typeof e && isFinite(e) && Math.floor(e) === e
12862 }
12863}), (function(e, t, n) {
12864 n(24), e.exports = n(27).Array.find
12865}), (function(e, t, n) {
12866 "use strict";
12867 var r = n(25),
12868 i = n(43)(5),
12869 o = "find",
12870 a = !0;
12871 o in [] && Array(1)[o]((function() {
12872 a = !1
12873 })), r(r.P + r.F * a, "Array", {
12874 find: function(e) {
12875 return i(this, e, arguments.length > 1 ? arguments[1] : void 0)
12876 }
12877 }), n(55)(o)
12878}), (function(e, t, n) {
12879 var r = n(26),
12880 i = n(27),
12881 o = n(28),
12882 a = n(38),
12883 s = n(41),
12884 d = "prototype",
12885 u = function(e, t, n) {
12886 var c, l, f, p, g = e & u.F,
12887 m = e & u.G,
12888 b = e & u.S,
12889 v = e & u.P,
12890 y = e & u.B,
12891 h = m ? r : b ? r[t] || (r[t] = {}) : (r[t] || {})[d],
12892 _ = m ? i : i[t] || (i[t] = {}),
12893 I = _[d] || (_[d] = {});
12894 m && (n = t);
12895 for (c in n) l = !g && h && void 0 !== h[c], f = (l ? h : n)[c], p = y && l ? s(f, r) : v && "function" == typeof f ? s(Function.call, f) : f, h && a(h, c, f, e & u.U), _[c] != f && o(_, c, p), v && I[c] != f && (I[c] = f)
12896 };
12897 r.core = i, u.F = 1, u.G = 2, u.S = 4, u.P = 8, u.B = 16, u.W = 32, u.U = 64, u.R = 128, e.exports = u
12898}), (function(e) {
12899 var t = e.exports = "undefined" != typeof window && window.Math == Math ? window : "undefined" != typeof self && self.Math == Math ? self : Function("return this")();
12900 "number" == typeof __g && (__g = t)
12901}), (function(e) {
12902 var t = e.exports = {
12903 version: "2.4.0"
12904 };
12905 "number" == typeof __e && (__e = t)
12906}), (function(e, t, n) {
12907 var r = n(29),
12908 i = n(37);
12909 e.exports = n(33) ? function(e, t, n) {
12910 return r.f(e, t, i(1, n))
12911 } : function(e, t, n) {
12912 return e[t] = n, e
12913 }
12914}), (function(e, t, n) {
12915 var r = n(30),
12916 i = n(32),
12917 o = n(36),
12918 a = Object.defineProperty;
12919 t.f = n(33) ? Object.defineProperty : function(e, t, n) {
12920 if (r(e), t = o(t, !0), r(n), i) try {
12921 return a(e, t, n)
12922 } catch (s) {}
12923 if ("get" in n || "set" in n) throw TypeError("Accessors not supported!");
12924 return "value" in n && (e[t] = n.value), e
12925 }
12926}), (function(e, t, n) {
12927 var r = n(31);
12928 e.exports = function(e) {
12929 if (!r(e)) throw TypeError(e + " is not an object!");
12930 return e
12931 }
12932}), (function(e) {
12933 e.exports = function(e) {
12934 return "object" == typeof e ? null !== e : "function" == typeof e
12935 }
12936}), (function(e, t, n) {
12937 e.exports = !n(33) && !n(34)((function() {
12938 return 7 != Object.defineProperty(n(35)("div"), "a", {
12939 get: function() {
12940 return 7
12941 }
12942 }).a
12943 }))
12944}), (function(e, t, n) {
12945 e.exports = !n(34)((function() {
12946 return 7 != Object.defineProperty({}, "a", {
12947 get: function() {
12948 return 7
12949 }
12950 }).a
12951 }))
12952}), (function(e) {
12953 e.exports = function(e) {
12954 try {
12955 return !!e()
12956 } catch (t) {
12957 return !0
12958 }
12959 }
12960}), (function(e, t, n) {
12961 var r = n(31),
12962 i = n(26).document,
12963 o = r(i) && r(i.createElement);
12964 e.exports = function(e) {
12965 return o ? i.createElement(e) : {}
12966 }
12967}), (function(e, t, n) {
12968 var r = n(31);
12969 e.exports = function(e, t) {
12970 if (!r(e)) return e;
12971 var n, i;
12972 if (t && "function" == typeof(n = e.toString) && !r(i = n.call(e))) return i;
12973 if ("function" == typeof(n = e.valueOf) && !r(i = n.call(e))) return i;
12974 if (!t && "function" == typeof(n = e.toString) && !r(i = n.call(e))) return i;
12975 throw TypeError("Can't convert object to primitive value")
12976 }
12977}), (function(e) {
12978 e.exports = function(e, t) {
12979 return {
12980 enumerable: !(1 & e),
12981 configurable: !(2 & e),
12982 writable: !(4 & e),
12983 value: t
12984 }
12985 }
12986}), (function(e, t, n) {
12987 var r = n(26),
12988 i = n(28),
12989 o = n(39),
12990 a = n(40)("src"),
12991 s = "toString",
12992 d = Function[s],
12993 u = ("" + d).split(s);
12994 n(27).inspectSource = function(e) {
12995 return d.call(e)
12996 }, (e.exports = function(e, t, n, s) {
12997 var d = "function" == typeof n;
12998 d && (o(n, "name") || i(n, "name", t)), e[t] !== n && (d && (o(n, a) || i(n, a, e[t] ? "" + e[t] : u.join(String(t)))), e === r ? e[t] = n : s ? e[t] ? e[t] = n : i(e, t, n) : (delete e[t], i(e, t, n)))
12999 })(Function.prototype, s, (function() {
13000 return "function" == typeof this && this[a] || d.call(this)
13001 }))
13002}), (function(e) {
13003 var t = {}.hasOwnProperty;
13004 e.exports = function(e, n) {
13005 return t.call(e, n)
13006 }
13007}), (function(e) {
13008 var t = 0,
13009 n = Math.random();
13010 e.exports = function(e) {
13011 return "Symbol(".concat(void 0 === e ? "" : e, ")_", (++t + n).toString(36))
13012 }
13013}), (function(e, t, n) {
13014 var r = n(42);
13015 e.exports = function(e, t, n) {
13016 if (r(e), void 0 === t) return e;
13017 switch (n) {
13018 case 1:
13019 return function(n) {
13020 return e.call(t, n)
13021 };
13022 case 2:
13023 return function(n, r) {
13024 return e.call(t, n, r)
13025 };
13026 case 3:
13027 return function(n, r, i) {
13028 return e.call(t, n, r, i)
13029 }
13030 }
13031 return function() {
13032 return e.apply(t, arguments)
13033 }
13034 }
13035}), (function(e) {
13036 e.exports = function(e) {
13037 if ("function" != typeof e) throw TypeError(e + " is not a function!");
13038 return e
13039 }
13040}), (function(e, t, n) {
13041 var r = n(41),
13042 i = n(44),
13043 o = n(46),
13044 a = n(48),
13045 s = n(50);
13046 e.exports = function(e, t) {
13047 var n = 1 == e,
13048 d = 2 == e,
13049 u = 3 == e,
13050 c = 4 == e,
13051 l = 6 == e,
13052 f = 5 == e || l,
13053 p = t || s;
13054 return function(t, s, g) {
13055 for (var m, b, v = o(t), y = i(v), h = r(s, g, 3), _ = a(y.length), I = 0, w = n ? p(t, _) : d ? p(t, 0) : void 0; _ > I; I++)
13056 if ((f || I in y) && (m = y[I], b = h(m, I, v), e))
13057 if (n) w[I] = b;
13058 else if (b) switch (e) {
13059 case 3:
13060 return !0;
13061 case 5:
13062 return m;
13063 case 6:
13064 return I;
13065 case 2:
13066 w.push(m)
13067 } else if (c) return !1;
13068 return l ? -1 : u || c ? c : w
13069 }
13070 }
13071}), (function(e, t, n) {
13072 var r = n(45);
13073 e.exports = Object("z").propertyIsEnumerable(0) ? Object : function(e) {
13074 return "String" == r(e) ? e.split("") : Object(e)
13075 }
13076}), (function(e) {
13077 var t = {}.toString;
13078 e.exports = function(e) {
13079 return t.call(e).slice(8, -1)
13080 }
13081}), (function(e, t, n) {
13082 var r = n(47);
13083 e.exports = function(e) {
13084 return Object(r(e))
13085 }
13086}), (function(e) {
13087 e.exports = function(e) {
13088 if (void 0 == e) throw TypeError("Can't call method on " + e);
13089 return e
13090 }
13091}), (function(e, t, n) {
13092 var r = n(49),
13093 i = Math.min;
13094 e.exports = function(e) {
13095 return e > 0 ? i(r(e), 9007199254740991) : 0
13096 }
13097}), (function(e) {
13098 var t = Math.ceil,
13099 n = Math.floor;
13100 e.exports = function(e) {
13101 return isNaN(e = +e) ? 0 : (e > 0 ? n : t)(e)
13102 }
13103}), (function(e, t, n) {
13104 var r = n(51);
13105 e.exports = function(e, t) {
13106 return new(r(e))(t)
13107 }
13108}), (function(e, t, n) {
13109 var r = n(31),
13110 i = n(52),
13111 o = n(53)("species");
13112 e.exports = function(e) {
13113 var t;
13114 return i(e) && (t = e.constructor, "function" != typeof t || t !== Array && !i(t.prototype) || (t = void 0), r(t) && (t = t[o], null === t && (t = void 0))), void 0 === t ? Array : t
13115 }
13116}), (function(e, t, n) {
13117 var r = n(45);
13118 e.exports = Array.isArray || function(e) {
13119 return "Array" == r(e)
13120 }
13121}), (function(e, t, n) {
13122 var r = n(54)("wks"),
13123 i = n(40),
13124 o = n(26).Symbol,
13125 a = "function" == typeof o,
13126 s = e.exports = function(e) {
13127 return r[e] || (r[e] = a && o[e] || (a ? o : i)("Symbol." + e))
13128 };
13129 s.store = r
13130}), (function(e, t, n) {
13131 var r = n(26),
13132 i = "__core-js_shared__",
13133 o = r[i] || (r[i] = {});
13134 e.exports = function(e) {
13135 return o[e] || (o[e] = {})
13136 }
13137}), (function(e, t, n) {
13138 var r = n(53)("unscopables"),
13139 i = Array.prototype;
13140 void 0 == i[r] && n(28)(i, r, {}), e.exports = function(e) {
13141 i[r][e] = !0
13142 }
13143}), (function(e, t, n) {
13144 n(57), e.exports = n(27).Array.includes
13145}), (function(e, t, n) {
13146 "use strict";
13147 var r = n(25),
13148 i = n(58)(!0);
13149 r(r.P, "Array", {
13150 includes: function(e) {
13151 return i(this, e, arguments.length > 1 ? arguments[1] : void 0)
13152 }
13153 }), n(55)("includes")
13154}), (function(e, t, n) {
13155 var r = n(59),
13156 i = n(48),
13157 o = n(60);
13158 e.exports = function(e) {
13159 return function(t, n, a) {
13160 var s, d = r(t),
13161 u = i(d.length),
13162 c = o(a, u);
13163 if (e && n != n) {
13164 for (; u > c;)
13165 if (s = d[c++], s != s) return !0
13166 } else
13167 for (; u > c; c++)
13168 if ((e || c in d) && d[c] === n) return e || c || 0;
13169 return !e && -1
13170 }
13171 }
13172}), (function(e, t, n) {
13173 var r = n(44),
13174 i = n(47);
13175 e.exports = function(e) {
13176 return r(i(e))
13177 }
13178}), (function(e, t, n) {
13179 var r = n(49),
13180 i = Math.max,
13181 o = Math.min;
13182 e.exports = function(e, t) {
13183 return e = r(e), 0 > e ? i(e + t, 0) : o(e, t)
13184 }
13185}), (function(e, t, n) {
13186 n(62), e.exports = n(27).Object.assign
13187}), (function(e, t, n) {
13188 var r = n(25);
13189 r(r.S + r.F, "Object", {
13190 assign: n(63)
13191 })
13192}), (function(e, t, n) {
13193 "use strict";
13194 var r = n(64),
13195 i = n(68),
13196 o = n(69),
13197 a = n(46),
13198 s = n(44),
13199 d = Object.assign;
13200 e.exports = !d || n(34)((function() {
13201 var e = {},
13202 t = {},
13203 n = Symbol(),
13204 r = "abcdefghijklmnopqrst";
13205 return e[n] = 7, r.split("").forEach((function(e) {
13206 t[e] = e
13207 })), 7 != d({}, e)[n] || Object.keys(d({}, t)).join("") != r
13208 })) ? function(e) {
13209 for (var t = a(e), n = arguments.length, d = 1, u = i.f, c = o.f; n > d;)
13210 for (var l, f = s(arguments[d++]), p = u ? r(f).concat(u(f)) : r(f), g = p.length, m = 0; g > m;) c.call(f, l = p[m++]) && (t[l] = f[l]);
13211 return t
13212 } : d
13213}), (function(e, t, n) {
13214 var r = n(65),
13215 i = n(67);
13216 e.exports = Object.keys || function(e) {
13217 return r(e, i)
13218 }
13219}), (function(e, t, n) {
13220 var r = n(39),
13221 i = n(59),
13222 o = n(58)(!1),
13223 a = n(66)("IE_PROTO");
13224 e.exports = function(e, t) {
13225 var n, s = i(e),
13226 d = 0,
13227 u = [];
13228 for (n in s) n != a && r(s, n) && u.push(n);
13229 for (; t.length > d;) r(s, n = t[d++]) && (~o(u, n) || u.push(n));
13230 return u
13231 }
13232}), (function(e, t, n) {
13233 var r = n(54)("keys"),
13234 i = n(40);
13235 e.exports = function(e) {
13236 return r[e] || (r[e] = i(e))
13237 }
13238}), (function(e) {
13239 e.exports = "constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(",")
13240}), (function(e, t) {
13241 t.f = Object.getOwnPropertySymbols
13242}), (function(e, t) {
13243 t.f = {}.propertyIsEnumerable
13244}), (function(e, t, n) {
13245 "use strict";
13246
13247 function r(e) {
13248 return e && e.__esModule ? e : {
13249 "default": e
13250 }
13251 }
13252
13253 function i() {
13254 addEventListener("message", o, !1)
13255 }
13256
13257 function o(e) {
13258 var t = e.message ? "message" : "data",
13259 n = {};
13260 try {
13261 n = JSON.parse(e[t])
13262 } catch (r) {
13263 return
13264 }
13265 if (n.adId) {
13266 var i = pbjs._bidsReceived.find((function(e) {
13267 return e.adId === n.adId
13268 }));
13269 "Prebid Request" === n.message && (a(i, n.adServerDomain, e.source), pbjs._winningBids.push(i), u["default"].emit(p, i)), "Prebid Native" === n.message && (l["default"](i), pbjs._winningBids.push(i), u["default"].emit(p, i))
13270 }
13271 }
13272
13273 function a(e, t, n) {
13274 var r = e.adId,
13275 i = e.ad,
13276 o = e.adUrl,
13277 a = e.width,
13278 d = e.height;
13279 r && (s(e), n.postMessage(JSON.stringify({
13280 message: "Prebid Response",
13281 ad: i,
13282 adUrl: o,
13283 adId: r,
13284 width: a,
13285 height: d
13286 }), t))
13287 }
13288
13289 function s(e) {
13290 var t = e.adUnitCode,
13291 n = e.width,
13292 r = e.height,
13293 i = document.getElementById(window.googletag.pubads().getSlots().find((function(e) {
13294 return e.getAdUnitPath() === t || e.getSlotElementId() === t
13295 })).getSlotElementId()).querySelector("iframe");
13296 i.width = "" + n, i.height = "" + r
13297 }
13298 Object.defineProperty(t, "__esModule", {
13299 value: !0
13300 }), t.listenMessagesFromCreative = i;
13301 var d = n(9),
13302 u = r(d),
13303 c = n(7),
13304 l = r(c),
13305 f = n(3),
13306 p = f.EVENTS.BID_WON
13307}), (function(e, t, n) {
13308 "use strict";
13309
13310 function r(e) {
13311 if (e && e.__esModule) return e;
13312 var t = {};
13313 if (null != e)
13314 for (var n in e) Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
13315 return t["default"] = e, t
13316 }
13317
13318 function i() {
13319 l.forEach((function(e) {
13320 u.logMessage("Invoking cookie sync for bidder: " + e.bidder), "iframe" === e.type ? u.insertCookieSyncIframe(e.url, !1) : u.insertPixel(e.url)
13321 })), l.length = 0
13322 }
13323
13324 function o(e) {
13325 for (var t = 0; t < document.links.length; t++) {
13326 var n = document.links[t];
13327 n.href = e + encodeURIComponent(n.href)
13328 }
13329 }
13330
13331 function a(e) {
13332 "true" !== document.cookie.replace(/(?:(?:^|.*;\s*)pbsCookiePersistFooter\s*\=\s*([^;]*).*$)|^.*$/, "$1") && (document.body.appendChild(s(e)), document.cookie = "pbsCookiePersistFooter=true; expires=Fri, 31 Dec 9999 23:59:59 GMT")
13333 }
13334
13335 function s(e) {
13336 var t = document.createElement("div");
13337 t.style.background = "#D3D3D3", t.style.color = "#555", t.style.boxShadow = "0 -1px 2px rgba(0, 0, 0, 0.2)", t.style.fontFamily = "sans-serif", t.style.lineHeight = "1.5", t.style.position = "fixed", t.style.bottom = "0", t.style.left = "0", t.style.right = "0", t.style.width = "100%", t.style.padding = "1em 0", t.style.zindex = "1000";
13338 var n = document.createElement("p");
13339 return n.style.margin = "0 2em", n.innerHTML = e, t.appendChild(n), t
13340 }
13341 var d = n(2),
13342 u = r(d),
13343 c = t,
13344 l = [];
13345 c.queueSync = function(e) {
13346 var t = e.bidder,
13347 n = e.url,
13348 r = e.type;
13349 l.push({
13350 bidder: t,
13351 url: n,
13352 type: r
13353 })
13354 }, c.syncCookies = function(e) {
13355 e ? setTimeout(i, e) : i()
13356 }, c.persist = function(e, t) {
13357 u.isSafariBrowser() && (o(e), a(t))
13358 }
13359}), (function(e, t, n) {
13360 "use strict";
13361 var r = n(20),
13362 i = n(73),
13363 o = function(e) {
13364 this.name = e.adserver, this.code = e.code, this.getWinningBidByCode = function() {
13365 return i.getWinningBids(this.code)[0]
13366 }
13367 };
13368 t.dfpAdserver = function(e, t) {
13369 var n = new o(e);
13370 n.urlComponents = t;
13371 var i = {
13372 env: "vp",
13373 gdfp_req: "1",
13374 impl: "s",
13375 unviewed_position_start: "1"
13376 },
13377 a = ["output", "iu", "sz", "url", "correlator", "description_url", "hl"],
13378 s = function(e) {
13379 return encodeURIComponent(r.formatQS(e))
13380 };
13381 return n.appendQueryParams = function() {
13382 var e = n.getWinningBidByCode();
13383 e && (this.urlComponents.search.description_url = encodeURIComponent(e.descriptionUrl), this.urlComponents.search.cust_params = s(e.adserverTargeting), this.urlComponents.search.correlator = Date.now())
13384 }, n.verifyAdserverTag = function() {
13385 for (var e in i)
13386 if (!this.urlComponents.search.hasOwnProperty(e) || this.urlComponents.search[e] !== i[e]) return !1;
13387 for (var t in a)
13388 if (!this.urlComponents.search.hasOwnProperty(a[t])) return !1;
13389 return !0
13390 }, n
13391 }
13392}), (function(e, t, n) {
13393 "use strict";
13394
13395 function r(e, t, n) {
13396 return t in e ? Object.defineProperty(e, t, {
13397 value: n,
13398 enumerable: !0,
13399 configurable: !0,
13400 writable: !0
13401 }) : e[t] = n, e
13402 }
13403
13404 function i(e) {
13405 return "string" == typeof e ? [e] : p.isArray(e) ? e : pbjs._adUnitCodes || []
13406 }
13407
13408 function o(e) {
13409 var t = m.getWinningBids(e),
13410 n = a();
13411 return t = t.map((function(e) {
13412 return r({}, e.adUnitCode, Object.keys(e.adserverTargeting).filter((function(t) {
13413 return "undefined" == typeof e.sendStandardTargeting || e.sendStandardTargeting || -1 === n.indexOf(t)
13414 })).map((function(t) {
13415 return r({}, t.substring(0, 20), [e.adserverTargeting[t]])
13416 })))
13417 }))
13418 }
13419
13420 function a() {
13421 return f.getStandardBidderAdServerTargeting().map((function(e) {
13422 return e.key
13423 })).concat(g.TARGETING_KEYS).filter(c.uniques)
13424 }
13425
13426 function s(e) {
13427 var t = a();
13428 return pbjs._bidsReceived.filter(c.adUnitsFilter.bind(this, e)).map((function(e) {
13429 return e.alwaysUseBid ? r({}, e.adUnitCode, Object.keys(e.adserverTargeting).map((function(n) {
13430 return t.indexOf(n) > -1 ? void 0 : r({}, n.substring(0, 20), [e.adserverTargeting[n]])
13431 })).filter((function(e) {
13432 return e
13433 }))) : void 0
13434 })).filter((function(e) {
13435 return e
13436 }))
13437 }
13438
13439 function d(e) {
13440 var t = g.TARGETING_KEYS.concat(l.NATIVE_TARGETING_KEYS);
13441 return pbjs._bidsReceived.filter(c.adUnitsFilter.bind(this, e)).map((function(e) {
13442 return e.adserverTargeting ? r({}, e.adUnitCode, u(e, t.filter((function(t) {
13443 return "undefined" != typeof e.adserverTargeting[t]
13444 })))) : void 0
13445 })).filter((function(e) {
13446 return e
13447 }))
13448 }
13449
13450 function u(e, t) {
13451 return t.map((function(t) {
13452 return r({}, (t + "_" + e.bidderCode).substring(0, 20), [e.adserverTargeting[t]])
13453 }))
13454 }
13455 var c = n(2),
13456 l = n(7),
13457 f = n(12),
13458 p = n(2),
13459 g = n(3),
13460 m = t,
13461 b = [];
13462 m.resetPresetTargeting = function(e) {
13463 if (c.isGptPubadsDefined()) {
13464 var t = i(e),
13465 n = pbjs.adUnits.filter((function(e) {
13466 return t.includes(e.code)
13467 }));
13468 window.googletag.pubads().getSlots().forEach((function(e) {
13469 b.forEach((function(t) {
13470 n.forEach((function(n) {
13471 (n.code === e.getAdUnitPath() || n.code === e.getSlotElementId()) && e.setTargeting(t, null)
13472 }))
13473 }))
13474 }))
13475 }
13476 }, m.getAllTargeting = function(e) {
13477 var t = i(e),
13478 n = o(t).concat(s(t)).concat(pbjs._sendAllBids ? d(t) : []);
13479 return n.map((function(e) {
13480 Object.keys(e).map((function(t) {
13481 e[t].map((function(e) {
13482 -1 === b.indexOf(Object.keys(e)[0]) && (b = Object.keys(e).concat(b))
13483 }))
13484 }))
13485 })), n
13486 }, m.setTargeting = function(e) {
13487 window.googletag.pubads().getSlots().forEach((function(t) {
13488 e.filter((function(e) {
13489 return Object.keys(e)[0] === t.getAdUnitPath() || Object.keys(e)[0] === t.getSlotElementId()
13490 })).forEach((function(e) {
13491 return e[Object.keys(e)[0]].forEach((function(e) {
13492 e[Object.keys(e)[0]].map((function(n) {
13493 return p.logMessage("Attempting to set key value for slot: " + t.getSlotElementId() + " key: " + Object.keys(e)[0] + " value: " + n), n
13494 })).forEach((function(n) {
13495 t.setTargeting(Object.keys(e)[0], n)
13496 }))
13497 }))
13498 }))
13499 }))
13500 }, m.getWinningBids = function(e) {
13501 var t = i(e);
13502 return pbjs._bidsReceived.filter((function(e) {
13503 return t.includes(e.adUnitCode)
13504 })).filter((function(e) {
13505 return e.cpm > 0
13506 })).map((function(e) {
13507 return e.adUnitCode
13508 })).filter(c.uniques).map((function(e) {
13509 return pbjs._bidsReceived.filter((function(t) {
13510 return t.adUnitCode === e ? t : null
13511 })).reduce(c.getHighestCpm, {
13512 adUnitCode: e,
13513 cpm: 0,
13514 adserverTargeting: {},
13515 timeToRespond: 0
13516 })
13517 }))
13518 }, m.setTargetingForAst = function() {
13519 var e = pbjs.getAdserverTargeting();
13520 Object.keys(e).forEach((function(t) {
13521 return Object.keys(e[t]).forEach((function(n) {
13522 if (p.logMessage("Attempting to set targeting for targetId: " + t + " key: " + n + " value: " + e[t][n]), p.isStr(e[t][n]) || p.isArray(e[t][n])) {
13523 var r = {},
13524 i = "hb_adid",
13525 o = n.substring(0, i.length) === i ? n.toUpperCase() : n;
13526 r[o] = e[t][n], window.apntag.setKeywords(t, r)
13527 }
13528 }))
13529 }))
13530 }, m.isApntagDefined = function() {
13531 return window.apntag && p.isFn(window.apntag.setKeywords) ? !0 : void 0
13532 }
13533})]);