prometheus-net
10598 строк · 273.8 Кб
1/*!
2* jQuery JavaScript Library v3.4.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: 2019-05-01T21:04Z
13*/
14( function( global, factory ) {15
16"use strict";17
18if ( 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.27module.exports = global.document ?28factory( global, true ) :29function( w ) {30if ( !w.document ) {31throw new Error( "jQuery requires a window with a document" );32}33return factory( w );34};35} else {36factory( 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
74var isFunction = function isFunction( obj ) {75
76// Support: Chrome <=57, Firefox <=5277// In some browsers, typeof returns "function" for HTML <object> elements78// (i.e., `typeof document.createElement( "object" ) === "function"`).79// We don't want to classify *any* DOM node as a function.80return typeof obj === "function" && typeof obj.nodeType !== "number";81};82
83
84var isWindow = function isWindow( obj ) {85return obj != null && obj === obj.window;86};87
88
89
90
91var preservedScriptAttributes = {92type: true,93src: true,94nonce: true,95noModule: true96};97
98function DOMEval( code, node, doc ) {99doc = doc || document;100
101var i, val,102script = doc.createElement( "script" );103
104script.text = code;105if ( node ) {106for ( i in preservedScriptAttributes ) {107
108// Support: Firefox 64+, Edge 18+109// Some browsers don't support the "nonce" property on scripts.110// On the other hand, just using `getAttribute` is not enough as111// the `nonce` attribute is reset to an empty string whenever it112// becomes browsing-context connected.113// See https://github.com/whatwg/html/issues/2369114// See https://html.spec.whatwg.org/#nonce-attributes115// The `node.getAttribute` check was added for the sake of116// `jQuery.globalEval` so that it can fake a nonce-containing node117// via an object.118val = node[ i ] || node.getAttribute && node.getAttribute( i );119if ( val ) {120script.setAttribute( i, val );121}122}123}124doc.head.appendChild( script ).parentNode.removeChild( script );125}126
127
128function toType( obj ) {129if ( obj == null ) {130return obj + "";131}132
133// Support: Android <=2.3 only (functionish RegExp)134return typeof obj === "object" || typeof obj === "function" ?135class2type[ toString.call( obj ) ] || "object" :136typeof obj;137}
138/* global Symbol */
139// Defining this global in .eslintrc.json would create a danger of using the global
140// unguarded in another place, it seems safer to define global only for this module
141
142
143
144var
145version = "3.4.1",146
147// Define a local copy of jQuery148jQuery = function( selector, context ) {149
150// The jQuery object is actually just the init constructor 'enhanced'151// Need init if jQuery is called (just allow error to be thrown if not included)152return new jQuery.fn.init( selector, context );153},154
155// Support: Android <=4.0 only156// Make sure we trim BOM and NBSP157rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;158
159jQuery.fn = jQuery.prototype = {160
161// The current version of jQuery being used162jquery: version,163
164constructor: jQuery,165
166// The default length of a jQuery object is 0167length: 0,168
169toArray: function() {170return slice.call( this );171},172
173// Get the Nth element in the matched element set OR174// Get the whole matched element set as a clean array175get: function( num ) {176
177// Return all the elements in a clean array178if ( num == null ) {179return slice.call( this );180}181
182// Return just the one element from the set183return num < 0 ? this[ num + this.length ] : this[ num ];184},185
186// Take an array of elements and push it onto the stack187// (returning the new matched element set)188pushStack: function( elems ) {189
190// Build a new jQuery matched element set191var ret = jQuery.merge( this.constructor(), elems );192
193// Add the old object onto the stack (as a reference)194ret.prevObject = this;195
196// Return the newly-formed element set197return ret;198},199
200// Execute a callback for every element in the matched set.201each: function( callback ) {202return jQuery.each( this, callback );203},204
205map: function( callback ) {206return this.pushStack( jQuery.map( this, function( elem, i ) {207return callback.call( elem, i, elem );208} ) );209},210
211slice: function() {212return this.pushStack( slice.apply( this, arguments ) );213},214
215first: function() {216return this.eq( 0 );217},218
219last: function() {220return this.eq( -1 );221},222
223eq: function( i ) {224var len = this.length,225j = +i + ( i < 0 ? len : 0 );226return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );227},228
229end: function() {230return this.prevObject || this.constructor();231},232
233// For internal use only.234// Behaves like an Array's method, not like a jQuery method.235push: push,236sort: arr.sort,237splice: arr.splice238};239
240jQuery.extend = jQuery.fn.extend = function() {241var options, name, src, copy, copyIsArray, clone,242target = arguments[ 0 ] || {},243i = 1,244length = arguments.length,245deep = false;246
247// Handle a deep copy situation248if ( typeof target === "boolean" ) {249deep = target;250
251// Skip the boolean and the target252target = arguments[ i ] || {};253i++;254}255
256// Handle case when target is a string or something (possible in deep copy)257if ( typeof target !== "object" && !isFunction( target ) ) {258target = {};259}260
261// Extend jQuery itself if only one argument is passed262if ( i === length ) {263target = this;264i--;265}266
267for ( ; i < length; i++ ) {268
269// Only deal with non-null/undefined values270if ( ( options = arguments[ i ] ) != null ) {271
272// Extend the base object273for ( name in options ) {274copy = options[ name ];275
276// Prevent Object.prototype pollution277// Prevent never-ending loop278if ( name === "__proto__" || target === copy ) {279continue;280}281
282// Recurse if we're merging plain objects or arrays283if ( deep && copy && ( jQuery.isPlainObject( copy ) ||284( copyIsArray = Array.isArray( copy ) ) ) ) {285src = target[ name ];286
287// Ensure proper type for the source value288if ( copyIsArray && !Array.isArray( src ) ) {289clone = [];290} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {291clone = {};292} else {293clone = src;294}295copyIsArray = false;296
297// Never move original objects, clone them298target[ name ] = jQuery.extend( deep, clone, copy );299
300// Don't bring in undefined values301} else if ( copy !== undefined ) {302target[ name ] = copy;303}304}305}306}307
308// Return the modified object309return target;310};311
312jQuery.extend( {313
314// Unique for each copy of jQuery on the page315expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),316
317// Assume jQuery is ready without the ready module318isReady: true,319
320error: function( msg ) {321throw new Error( msg );322},323
324noop: function() {},325
326isPlainObject: function( obj ) {327var proto, Ctor;328
329// Detect obvious negatives330// Use toString instead of jQuery.type to catch host objects331if ( !obj || toString.call( obj ) !== "[object Object]" ) {332return false;333}334
335proto = getProto( obj );336
337// Objects with no prototype (e.g., `Object.create( null )`) are plain338if ( !proto ) {339return true;340}341
342// Objects with prototype are plain iff they were constructed by a global Object function343Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;344return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;345},346
347isEmptyObject: function( obj ) {348var name;349
350for ( name in obj ) {351return false;352}353return true;354},355
356// Evaluates a script in a global context357globalEval: function( code, options ) {358DOMEval( code, { nonce: options && options.nonce } );359},360
361each: function( obj, callback ) {362var length, i = 0;363
364if ( isArrayLike( obj ) ) {365length = obj.length;366for ( ; i < length; i++ ) {367if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {368break;369}370}371} else {372for ( i in obj ) {373if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {374break;375}376}377}378
379return obj;380},381
382// Support: Android <=4.0 only383trim: function( text ) {384return text == null ?385"" :386( text + "" ).replace( rtrim, "" );387},388
389// results is for internal usage only390makeArray: function( arr, results ) {391var ret = results || [];392
393if ( arr != null ) {394if ( isArrayLike( Object( arr ) ) ) {395jQuery.merge( ret,396typeof arr === "string" ?397[ arr ] : arr398);399} else {400push.call( ret, arr );401}402}403
404return ret;405},406
407inArray: function( elem, arr, i ) {408return arr == null ? -1 : indexOf.call( arr, elem, i );409},410
411// Support: Android <=4.0 only, PhantomJS 1 only412// push.apply(_, arraylike) throws on ancient WebKit413merge: function( first, second ) {414var len = +second.length,415j = 0,416i = first.length;417
418for ( ; j < len; j++ ) {419first[ i++ ] = second[ j ];420}421
422first.length = i;423
424return first;425},426
427grep: function( elems, callback, invert ) {428var callbackInverse,429matches = [],430i = 0,431length = elems.length,432callbackExpect = !invert;433
434// Go through the array, only saving the items435// that pass the validator function436for ( ; i < length; i++ ) {437callbackInverse = !callback( elems[ i ], i );438if ( callbackInverse !== callbackExpect ) {439matches.push( elems[ i ] );440}441}442
443return matches;444},445
446// arg is for internal usage only447map: function( elems, callback, arg ) {448var length, value,449i = 0,450ret = [];451
452// Go through the array, translating each of the items to their new values453if ( isArrayLike( elems ) ) {454length = elems.length;455for ( ; i < length; i++ ) {456value = callback( elems[ i ], i, arg );457
458if ( value != null ) {459ret.push( value );460}461}462
463// Go through every key on the object,464} else {465for ( i in elems ) {466value = callback( elems[ i ], i, arg );467
468if ( value != null ) {469ret.push( value );470}471}472}473
474// Flatten any nested arrays475return concat.apply( [], ret );476},477
478// A global GUID counter for objects479guid: 1,480
481// jQuery.support is not used in Core but other projects attach their482// properties to it so it needs to exist.483support: support484} );485
486if ( typeof Symbol === "function" ) {487jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];488}
489
490// Populate the class2type map
491jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),492function( i, name ) {493class2type[ "[object " + name + "]" ] = name.toLowerCase();494} );495
496function isArrayLike( obj ) {497
498// Support: real iOS 8.2 only (not reproducible in simulator)499// `in` check used to prevent JIT error (gh-2145)500// hasOwn isn't used here due to false negatives501// regarding Nodelist length in IE502var length = !!obj && "length" in obj && obj.length,503type = toType( obj );504
505if ( isFunction( obj ) || isWindow( obj ) ) {506return false;507}508
509return type === "array" || length === 0 ||510typeof length === "number" && length > 0 && ( length - 1 ) in obj;511}
512var Sizzle =513/*!
514* Sizzle CSS Selector Engine v2.3.4
515* https://sizzlejs.com/
516*
517* Copyright JS Foundation and other contributors
518* Released under the MIT license
519* https://js.foundation/
520*
521* Date: 2019-04-08
522*/
523(function( window ) {524
525var i,526support,527Expr,528getText,529isXML,530tokenize,531compile,532select,533outermostContext,534sortInput,535hasDuplicate,536
537// Local document vars538setDocument,539document,540docElem,541documentIsHTML,542rbuggyQSA,543rbuggyMatches,544matches,545contains,546
547// Instance-specific data548expando = "sizzle" + 1 * new Date(),549preferredDoc = window.document,550dirruns = 0,551done = 0,552classCache = createCache(),553tokenCache = createCache(),554compilerCache = createCache(),555nonnativeSelectorCache = createCache(),556sortOrder = function( a, b ) {557if ( a === b ) {558hasDuplicate = true;559}560return 0;561},562
563// Instance methods564hasOwn = ({}).hasOwnProperty,565arr = [],566pop = arr.pop,567push_native = arr.push,568push = arr.push,569slice = arr.slice,570// Use a stripped-down indexOf as it's faster than native571// https://jsperf.com/thor-indexof-vs-for/5572indexOf = function( list, elem ) {573var i = 0,574len = list.length;575for ( ; i < len; i++ ) {576if ( list[i] === elem ) {577return i;578}579}580return -1;581},582
583booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",584
585// Regular expressions586
587// http://www.w3.org/TR/css3-selectors/#whitespace588whitespace = "[\\x20\\t\\r\\n\\f]",589
590// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier591identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",592
593// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors594attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +595// Operator (capture 2)596"*([*^$|!~]?=)" + whitespace +597// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"598"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +599"*\\]",600
601pseudos = ":(" + identifier + ")(?:\\((" +602// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:603// 1. quoted (capture 3; capture 4 or capture 5)604"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +605// 2. simple (capture 6)606"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +607// 3. anything else (capture 2)608".*" +609")\\)|)",610
611// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter612rwhitespace = new RegExp( whitespace + "+", "g" ),613rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),614
615rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),616rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),617rdescend = new RegExp( whitespace + "|>" ),618
619rpseudo = new RegExp( pseudos ),620ridentifier = new RegExp( "^" + identifier + "$" ),621
622matchExpr = {623"ID": new RegExp( "^#(" + identifier + ")" ),624"CLASS": new RegExp( "^\\.(" + identifier + ")" ),625"TAG": new RegExp( "^(" + identifier + "|[*])" ),626"ATTR": new RegExp( "^" + attributes ),627"PSEUDO": new RegExp( "^" + pseudos ),628"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +629"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +630"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),631"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),632// For use in libraries implementing .is()633// We use this for POS matching in `select`634"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +635whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )636},637
638rhtml = /HTML$/i,639rinputs = /^(?:input|select|textarea|button)$/i,640rheader = /^h\d$/i,641
642rnative = /^[^{]+\{\s*\[native \w/,643
644// Easily-parseable/retrievable ID or TAG or CLASS selectors645rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,646
647rsibling = /[+~]/,648
649// CSS escapes650// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters651runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),652funescape = function( _, escaped, escapedWhitespace ) {653var high = "0x" + escaped - 0x10000;654// NaN means non-codepoint655// Support: Firefox<24656// Workaround erroneous numeric interpretation of +"0x"657return high !== high || escapedWhitespace ?658escaped :659high < 0 ?660// BMP codepoint661String.fromCharCode( high + 0x10000 ) :662// Supplemental Plane codepoint (surrogate pair)663String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );664},665
666// CSS string/identifier serialization667// https://drafts.csswg.org/cssom/#common-serializing-idioms668rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,669fcssescape = function( ch, asCodePoint ) {670if ( asCodePoint ) {671
672// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER673if ( ch === "\0" ) {674return "\uFFFD";675}676
677// Control characters and (dependent upon position) numbers get escaped as code points678return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";679}680
681// Other potentially-special ASCII characters get backslash-escaped682return "\\" + ch;683},684
685// Used for iframes686// See setDocument()687// Removing the function wrapper causes a "Permission Denied"688// error in IE689unloadHandler = function() {690setDocument();691},692
693inDisabledFieldset = addCombinator(694function( elem ) {695return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";696},697{ dir: "parentNode", next: "legend" }698);699
700// Optimize for push.apply( _, NodeList )
701try {702push.apply(703(arr = slice.call( preferredDoc.childNodes )),704preferredDoc.childNodes705);706// Support: Android<4.0707// Detect silently failing push.apply708arr[ preferredDoc.childNodes.length ].nodeType;709} catch ( e ) {710push = { apply: arr.length ?711
712// Leverage slice if possible713function( target, els ) {714push_native.apply( target, slice.call(els) );715} :716
717// Support: IE<9718// Otherwise append directly719function( target, els ) {720var j = target.length,721i = 0;722// Can't trust NodeList.length723while ( (target[j++] = els[i++]) ) {}724target.length = j - 1;725}726};727}
728
729function Sizzle( selector, context, results, seed ) {730var m, i, elem, nid, match, groups, newSelector,731newContext = context && context.ownerDocument,732
733// nodeType defaults to 9, since context defaults to document734nodeType = context ? context.nodeType : 9;735
736results = results || [];737
738// Return early from calls with invalid selector or context739if ( typeof selector !== "string" || !selector ||740nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {741
742return results;743}744
745// Try to shortcut find operations (as opposed to filters) in HTML documents746if ( !seed ) {747
748if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {749setDocument( context );750}751context = context || document;752
753if ( documentIsHTML ) {754
755// If the selector is sufficiently simple, try using a "get*By*" DOM method756// (excepting DocumentFragment context, where the methods don't exist)757if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {758
759// ID selector760if ( (m = match[1]) ) {761
762// Document context763if ( nodeType === 9 ) {764if ( (elem = context.getElementById( m )) ) {765
766// Support: IE, Opera, Webkit767// TODO: identify versions768// getElementById can match elements by name instead of ID769if ( elem.id === m ) {770results.push( elem );771return results;772}773} else {774return results;775}776
777// Element context778} else {779
780// Support: IE, Opera, Webkit781// TODO: identify versions782// getElementById can match elements by name instead of ID783if ( newContext && (elem = newContext.getElementById( m )) &&784contains( context, elem ) &&785elem.id === m ) {786
787results.push( elem );788return results;789}790}791
792// Type selector793} else if ( match[2] ) {794push.apply( results, context.getElementsByTagName( selector ) );795return results;796
797// Class selector798} else if ( (m = match[3]) && support.getElementsByClassName &&799context.getElementsByClassName ) {800
801push.apply( results, context.getElementsByClassName( m ) );802return results;803}804}805
806// Take advantage of querySelectorAll807if ( support.qsa &&808!nonnativeSelectorCache[ selector + " " ] &&809(!rbuggyQSA || !rbuggyQSA.test( selector )) &&810
811// Support: IE 8 only812// Exclude object elements813(nodeType !== 1 || context.nodeName.toLowerCase() !== "object") ) {814
815newSelector = selector;816newContext = context;817
818// qSA considers elements outside a scoping root when evaluating child or819// descendant combinators, which is not what we want.820// In such cases, we work around the behavior by prefixing every selector in the821// list with an ID selector referencing the scope context.822// Thanks to Andrew Dupont for this technique.823if ( nodeType === 1 && rdescend.test( selector ) ) {824
825// Capture the context ID, setting it first if necessary826if ( (nid = context.getAttribute( "id" )) ) {827nid = nid.replace( rcssescape, fcssescape );828} else {829context.setAttribute( "id", (nid = expando) );830}831
832// Prefix every selector in the list833groups = tokenize( selector );834i = groups.length;835while ( i-- ) {836groups[i] = "#" + nid + " " + toSelector( groups[i] );837}838newSelector = groups.join( "," );839
840// Expand context for sibling selectors841newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||842context;843}844
845try {846push.apply( results,847newContext.querySelectorAll( newSelector )848);849return results;850} catch ( qsaError ) {851nonnativeSelectorCache( selector, true );852} finally {853if ( nid === expando ) {854context.removeAttribute( "id" );855}856}857}858}859}860
861// All others862return select( selector.replace( rtrim, "$1" ), context, results, seed );863}
864
865/**
866* Create key-value caches of limited size
867* @returns {function(string, object)} Returns the Object data after storing it on itself with
868* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
869* deleting the oldest entry
870*/
871function createCache() {872var keys = [];873
874function cache( key, value ) {875// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)876if ( keys.push( key + " " ) > Expr.cacheLength ) {877// Only keep the most recent entries878delete cache[ keys.shift() ];879}880return (cache[ key + " " ] = value);881}882return cache;883}
884
885/**
886* Mark a function for special use by Sizzle
887* @param {Function} fn The function to mark
888*/
889function markFunction( fn ) {890fn[ expando ] = true;891return fn;892}
893
894/**
895* Support testing using an element
896* @param {Function} fn Passed the created element and returns a boolean result
897*/
898function assert( fn ) {899var el = document.createElement("fieldset");900
901try {902return !!fn( el );903} catch (e) {904return false;905} finally {906// Remove from its parent by default907if ( el.parentNode ) {908el.parentNode.removeChild( el );909}910// release memory in IE911el = null;912}913}
914
915/**
916* Adds the same handler for all of the specified attrs
917* @param {String} attrs Pipe-separated list of attributes
918* @param {Function} handler The method that will be applied
919*/
920function addHandle( attrs, handler ) {921var arr = attrs.split("|"),922i = arr.length;923
924while ( i-- ) {925Expr.attrHandle[ arr[i] ] = handler;926}927}
928
929/**
930* Checks document order of two siblings
931* @param {Element} a
932* @param {Element} b
933* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
934*/
935function siblingCheck( a, b ) {936var cur = b && a,937diff = cur && a.nodeType === 1 && b.nodeType === 1 &&938a.sourceIndex - b.sourceIndex;939
940// Use IE sourceIndex if available on both nodes941if ( diff ) {942return diff;943}944
945// Check if b follows a946if ( cur ) {947while ( (cur = cur.nextSibling) ) {948if ( cur === b ) {949return -1;950}951}952}953
954return a ? 1 : -1;955}
956
957/**
958* Returns a function to use in pseudos for input types
959* @param {String} type
960*/
961function createInputPseudo( type ) {962return function( elem ) {963var name = elem.nodeName.toLowerCase();964return name === "input" && elem.type === type;965};966}
967
968/**
969* Returns a function to use in pseudos for buttons
970* @param {String} type
971*/
972function createButtonPseudo( type ) {973return function( elem ) {974var name = elem.nodeName.toLowerCase();975return (name === "input" || name === "button") && elem.type === type;976};977}
978
979/**
980* Returns a function to use in pseudos for :enabled/:disabled
981* @param {Boolean} disabled true for :disabled; false for :enabled
982*/
983function createDisabledPseudo( disabled ) {984
985// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable986return function( elem ) {987
988// Only certain elements can match :enabled or :disabled989// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled990// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled991if ( "form" in elem ) {992
993// Check for inherited disabledness on relevant non-disabled elements:994// * listed form-associated elements in a disabled fieldset995// https://html.spec.whatwg.org/multipage/forms.html#category-listed996// https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled997// * option elements in a disabled optgroup998// https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled999// All such elements have a "form" property.1000if ( elem.parentNode && elem.disabled === false ) {1001
1002// Option elements defer to a parent optgroup if present1003if ( "label" in elem ) {1004if ( "label" in elem.parentNode ) {1005return elem.parentNode.disabled === disabled;1006} else {1007return elem.disabled === disabled;1008}1009}1010
1011// Support: IE 6 - 111012// Use the isDisabled shortcut property to check for disabled fieldset ancestors1013return elem.isDisabled === disabled ||1014
1015// Where there is no isDisabled, check manually1016/* jshint -W018 */1017elem.isDisabled !== !disabled &&1018inDisabledFieldset( elem ) === disabled;1019}1020
1021return elem.disabled === disabled;1022
1023// Try to winnow out elements that can't be disabled before trusting the disabled property.1024// Some victims get caught in our net (label, legend, menu, track), but it shouldn't1025// even exist on them, let alone have a boolean value.1026} else if ( "label" in elem ) {1027return elem.disabled === disabled;1028}1029
1030// Remaining elements are neither :enabled nor :disabled1031return false;1032};1033}
1034
1035/**
1036* Returns a function to use in pseudos for positionals
1037* @param {Function} fn
1038*/
1039function createPositionalPseudo( fn ) {1040return markFunction(function( argument ) {1041argument = +argument;1042return markFunction(function( seed, matches ) {1043var j,1044matchIndexes = fn( [], seed.length, argument ),1045i = matchIndexes.length;1046
1047// Match elements found at the specified indexes1048while ( i-- ) {1049if ( seed[ (j = matchIndexes[i]) ] ) {1050seed[j] = !(matches[j] = seed[j]);1051}1052}1053});1054});1055}
1056
1057/**
1058* Checks a node for validity as a Sizzle context
1059* @param {Element|Object=} context
1060* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1061*/
1062function testContext( context ) {1063return context && typeof context.getElementsByTagName !== "undefined" && context;1064}
1065
1066// Expose support vars for convenience
1067support = Sizzle.support = {};1068
1069/**
1070* Detects XML nodes
1071* @param {Element|Object} elem An element or a document
1072* @returns {Boolean} True iff elem is a non-HTML XML node
1073*/
1074isXML = Sizzle.isXML = function( elem ) {1075var namespace = elem.namespaceURI,1076docElem = (elem.ownerDocument || elem).documentElement;1077
1078// Support: IE <=81079// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes1080// https://bugs.jquery.com/ticket/48331081return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );1082};1083
1084/**
1085* Sets document-related variables once based on the current document
1086* @param {Element|Object} [doc] An element or document object to use to set the document
1087* @returns {Object} Returns the current document
1088*/
1089setDocument = Sizzle.setDocument = function( node ) {1090var hasCompare, subWindow,1091doc = node ? node.ownerDocument || node : preferredDoc;1092
1093// Return early if doc is invalid or already selected1094if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {1095return document;1096}1097
1098// Update global variables1099document = doc;1100docElem = document.documentElement;1101documentIsHTML = !isXML( document );1102
1103// Support: IE 9-11, Edge1104// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)1105if ( preferredDoc !== document &&1106(subWindow = document.defaultView) && subWindow.top !== subWindow ) {1107
1108// Support: IE 11, Edge1109if ( subWindow.addEventListener ) {1110subWindow.addEventListener( "unload", unloadHandler, false );1111
1112// Support: IE 9 - 10 only1113} else if ( subWindow.attachEvent ) {1114subWindow.attachEvent( "onunload", unloadHandler );1115}1116}1117
1118/* Attributes1119---------------------------------------------------------------------- */
1120
1121// Support: IE<81122// Verify that getAttribute really returns attributes and not properties1123// (excepting IE8 booleans)1124support.attributes = assert(function( el ) {1125el.className = "i";1126return !el.getAttribute("className");1127});1128
1129/* getElement(s)By*1130---------------------------------------------------------------------- */
1131
1132// Check if getElementsByTagName("*") returns only elements1133support.getElementsByTagName = assert(function( el ) {1134el.appendChild( document.createComment("") );1135return !el.getElementsByTagName("*").length;1136});1137
1138// Support: IE<91139support.getElementsByClassName = rnative.test( document.getElementsByClassName );1140
1141// Support: IE<101142// Check if getElementById returns elements by name1143// The broken getElementById methods don't pick up programmatically-set names,1144// so use a roundabout getElementsByName test1145support.getById = assert(function( el ) {1146docElem.appendChild( el ).id = expando;1147return !document.getElementsByName || !document.getElementsByName( expando ).length;1148});1149
1150// ID filter and find1151if ( support.getById ) {1152Expr.filter["ID"] = function( id ) {1153var attrId = id.replace( runescape, funescape );1154return function( elem ) {1155return elem.getAttribute("id") === attrId;1156};1157};1158Expr.find["ID"] = function( id, context ) {1159if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {1160var elem = context.getElementById( id );1161return elem ? [ elem ] : [];1162}1163};1164} else {1165Expr.filter["ID"] = function( id ) {1166var attrId = id.replace( runescape, funescape );1167return function( elem ) {1168var node = typeof elem.getAttributeNode !== "undefined" &&1169elem.getAttributeNode("id");1170return node && node.value === attrId;1171};1172};1173
1174// Support: IE 6 - 7 only1175// getElementById is not reliable as a find shortcut1176Expr.find["ID"] = function( id, context ) {1177if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {1178var node, i, elems,1179elem = context.getElementById( id );1180
1181if ( elem ) {1182
1183// Verify the id attribute1184node = elem.getAttributeNode("id");1185if ( node && node.value === id ) {1186return [ elem ];1187}1188
1189// Fall back on getElementsByName1190elems = context.getElementsByName( id );1191i = 0;1192while ( (elem = elems[i++]) ) {1193node = elem.getAttributeNode("id");1194if ( node && node.value === id ) {1195return [ elem ];1196}1197}1198}1199
1200return [];1201}1202};1203}1204
1205// Tag1206Expr.find["TAG"] = support.getElementsByTagName ?1207function( tag, context ) {1208if ( typeof context.getElementsByTagName !== "undefined" ) {1209return context.getElementsByTagName( tag );1210
1211// DocumentFragment nodes don't have gEBTN1212} else if ( support.qsa ) {1213return context.querySelectorAll( tag );1214}1215} :1216
1217function( tag, context ) {1218var elem,1219tmp = [],1220i = 0,1221// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too1222results = context.getElementsByTagName( tag );1223
1224// Filter out possible comments1225if ( tag === "*" ) {1226while ( (elem = results[i++]) ) {1227if ( elem.nodeType === 1 ) {1228tmp.push( elem );1229}1230}1231
1232return tmp;1233}1234return results;1235};1236
1237// Class1238Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {1239if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {1240return context.getElementsByClassName( className );1241}1242};1243
1244/* QSA/matchesSelector1245---------------------------------------------------------------------- */
1246
1247// QSA and matchesSelector support1248
1249// matchesSelector(:active) reports false when true (IE9/Opera 11.5)1250rbuggyMatches = [];1251
1252// qSa(:focus) reports false when true (Chrome 21)1253// We allow this because of a bug in IE8/9 that throws an error1254// whenever `document.activeElement` is accessed on an iframe1255// So, we allow :focus to pass through QSA all the time to avoid the IE error1256// See https://bugs.jquery.com/ticket/133781257rbuggyQSA = [];1258
1259if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {1260// Build QSA regex1261// Regex strategy adopted from Diego Perini1262assert(function( el ) {1263// Select is set to empty string on purpose1264// This is to test IE's treatment of not explicitly1265// setting a boolean content attribute,1266// since its presence should be enough1267// https://bugs.jquery.com/ticket/123591268docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +1269"<select id='" + expando + "-\r\\' msallowcapture=''>" +1270"<option selected=''></option></select>";1271
1272// Support: IE8, Opera 11-12.161273// Nothing should be selected when empty strings follow ^= or $= or *=1274// The test attribute must be unknown in Opera but "safe" for WinRT1275// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section1276if ( el.querySelectorAll("[msallowcapture^='']").length ) {1277rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );1278}1279
1280// Support: IE81281// Boolean attributes and "value" are not treated correctly1282if ( !el.querySelectorAll("[selected]").length ) {1283rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );1284}1285
1286// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+1287if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {1288rbuggyQSA.push("~=");1289}1290
1291// Webkit/Opera - :checked should return selected option elements1292// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked1293// IE8 throws error here and will not see later tests1294if ( !el.querySelectorAll(":checked").length ) {1295rbuggyQSA.push(":checked");1296}1297
1298// Support: Safari 8+, iOS 8+1299// https://bugs.webkit.org/show_bug.cgi?id=1368511300// In-page `selector#id sibling-combinator selector` fails1301if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {1302rbuggyQSA.push(".#.+[+~]");1303}1304});1305
1306assert(function( el ) {1307el.innerHTML = "<a href='' disabled='disabled'></a>" +1308"<select disabled='disabled'><option/></select>";1309
1310// Support: Windows 8 Native Apps1311// The type and name attributes are restricted during .innerHTML assignment1312var input = document.createElement("input");1313input.setAttribute( "type", "hidden" );1314el.appendChild( input ).setAttribute( "name", "D" );1315
1316// Support: IE81317// Enforce case-sensitivity of name attribute1318if ( el.querySelectorAll("[name=d]").length ) {1319rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );1320}1321
1322// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)1323// IE8 throws error here and will not see later tests1324if ( el.querySelectorAll(":enabled").length !== 2 ) {1325rbuggyQSA.push( ":enabled", ":disabled" );1326}1327
1328// Support: IE9-11+1329// IE's :disabled selector does not pick up the children of disabled fieldsets1330docElem.appendChild( el ).disabled = true;1331if ( el.querySelectorAll(":disabled").length !== 2 ) {1332rbuggyQSA.push( ":enabled", ":disabled" );1333}1334
1335// Opera 10-11 does not throw on post-comma invalid pseudos1336el.querySelectorAll("*,:x");1337rbuggyQSA.push(",.*:");1338});1339}1340
1341if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||1342docElem.webkitMatchesSelector ||1343docElem.mozMatchesSelector ||1344docElem.oMatchesSelector ||1345docElem.msMatchesSelector) )) ) {1346
1347assert(function( el ) {1348// Check to see if it's possible to do matchesSelector1349// on a disconnected node (IE 9)1350support.disconnectedMatch = matches.call( el, "*" );1351
1352// This should fail with an exception1353// Gecko does not error, returns false instead1354matches.call( el, "[s!='']:x" );1355rbuggyMatches.push( "!=", pseudos );1356});1357}1358
1359rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );1360rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );1361
1362/* Contains1363---------------------------------------------------------------------- */
1364hasCompare = rnative.test( docElem.compareDocumentPosition );1365
1366// Element contains another1367// Purposefully self-exclusive1368// As in, an element does not contain itself1369contains = hasCompare || rnative.test( docElem.contains ) ?1370function( a, b ) {1371var adown = a.nodeType === 9 ? a.documentElement : a,1372bup = b && b.parentNode;1373return a === bup || !!( bup && bup.nodeType === 1 && (1374adown.contains ?1375adown.contains( bup ) :1376a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 161377));1378} :1379function( a, b ) {1380if ( b ) {1381while ( (b = b.parentNode) ) {1382if ( b === a ) {1383return true;1384}1385}1386}1387return false;1388};1389
1390/* Sorting1391---------------------------------------------------------------------- */
1392
1393// Document order sorting1394sortOrder = hasCompare ?1395function( a, b ) {1396
1397// Flag for duplicate removal1398if ( a === b ) {1399hasDuplicate = true;1400return 0;1401}1402
1403// Sort on method existence if only one input has compareDocumentPosition1404var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;1405if ( compare ) {1406return compare;1407}1408
1409// Calculate position if both inputs belong to the same document1410compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?1411a.compareDocumentPosition( b ) :1412
1413// Otherwise we know they are disconnected14141;1415
1416// Disconnected nodes1417if ( compare & 1 ||1418(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {1419
1420// Choose the first element that is related to our preferred document1421if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {1422return -1;1423}1424if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {1425return 1;1426}1427
1428// Maintain original order1429return sortInput ?1430( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :14310;1432}1433
1434return compare & 4 ? -1 : 1;1435} :1436function( a, b ) {1437// Exit early if the nodes are identical1438if ( a === b ) {1439hasDuplicate = true;1440return 0;1441}1442
1443var cur,1444i = 0,1445aup = a.parentNode,1446bup = b.parentNode,1447ap = [ a ],1448bp = [ b ];1449
1450// Parentless nodes are either documents or disconnected1451if ( !aup || !bup ) {1452return a === document ? -1 :1453b === document ? 1 :1454aup ? -1 :1455bup ? 1 :1456sortInput ?1457( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :14580;1459
1460// If the nodes are siblings, we can do a quick check1461} else if ( aup === bup ) {1462return siblingCheck( a, b );1463}1464
1465// Otherwise we need full lists of their ancestors for comparison1466cur = a;1467while ( (cur = cur.parentNode) ) {1468ap.unshift( cur );1469}1470cur = b;1471while ( (cur = cur.parentNode) ) {1472bp.unshift( cur );1473}1474
1475// Walk down the tree looking for a discrepancy1476while ( ap[i] === bp[i] ) {1477i++;1478}1479
1480return i ?1481// Do a sibling check if the nodes have a common ancestor1482siblingCheck( ap[i], bp[i] ) :1483
1484// Otherwise nodes in our document sort first1485ap[i] === preferredDoc ? -1 :1486bp[i] === preferredDoc ? 1 :14870;1488};1489
1490return document;1491};1492
1493Sizzle.matches = function( expr, elements ) {1494return Sizzle( expr, null, null, elements );1495};1496
1497Sizzle.matchesSelector = function( elem, expr ) {1498// Set document vars if needed1499if ( ( elem.ownerDocument || elem ) !== document ) {1500setDocument( elem );1501}1502
1503if ( support.matchesSelector && documentIsHTML &&1504!nonnativeSelectorCache[ expr + " " ] &&1505( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&1506( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {1507
1508try {1509var ret = matches.call( elem, expr );1510
1511// IE 9's matchesSelector returns false on disconnected nodes1512if ( ret || support.disconnectedMatch ||1513// As well, disconnected nodes are said to be in a document1514// fragment in IE 91515elem.document && elem.document.nodeType !== 11 ) {1516return ret;1517}1518} catch (e) {1519nonnativeSelectorCache( expr, true );1520}1521}1522
1523return Sizzle( expr, document, null, [ elem ] ).length > 0;1524};1525
1526Sizzle.contains = function( context, elem ) {1527// Set document vars if needed1528if ( ( context.ownerDocument || context ) !== document ) {1529setDocument( context );1530}1531return contains( context, elem );1532};1533
1534Sizzle.attr = function( elem, name ) {1535// Set document vars if needed1536if ( ( elem.ownerDocument || elem ) !== document ) {1537setDocument( elem );1538}1539
1540var fn = Expr.attrHandle[ name.toLowerCase() ],1541// Don't get fooled by Object.prototype properties (jQuery #13807)1542val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?1543fn( elem, name, !documentIsHTML ) :1544undefined;1545
1546return val !== undefined ?1547val :1548support.attributes || !documentIsHTML ?1549elem.getAttribute( name ) :1550(val = elem.getAttributeNode(name)) && val.specified ?1551val.value :1552null;1553};1554
1555Sizzle.escape = function( sel ) {1556return (sel + "").replace( rcssescape, fcssescape );1557};1558
1559Sizzle.error = function( msg ) {1560throw new Error( "Syntax error, unrecognized expression: " + msg );1561};1562
1563/**
1564* Document sorting and removing duplicates
1565* @param {ArrayLike} results
1566*/
1567Sizzle.uniqueSort = function( results ) {1568var elem,1569duplicates = [],1570j = 0,1571i = 0;1572
1573// Unless we *know* we can detect duplicates, assume their presence1574hasDuplicate = !support.detectDuplicates;1575sortInput = !support.sortStable && results.slice( 0 );1576results.sort( sortOrder );1577
1578if ( hasDuplicate ) {1579while ( (elem = results[i++]) ) {1580if ( elem === results[ i ] ) {1581j = duplicates.push( i );1582}1583}1584while ( j-- ) {1585results.splice( duplicates[ j ], 1 );1586}1587}1588
1589// Clear input after sorting to release objects1590// See https://github.com/jquery/sizzle/pull/2251591sortInput = null;1592
1593return results;1594};1595
1596/**
1597* Utility function for retrieving the text value of an array of DOM nodes
1598* @param {Array|Element} elem
1599*/
1600getText = Sizzle.getText = function( elem ) {1601var node,1602ret = "",1603i = 0,1604nodeType = elem.nodeType;1605
1606if ( !nodeType ) {1607// If no nodeType, this is expected to be an array1608while ( (node = elem[i++]) ) {1609// Do not traverse comment nodes1610ret += getText( node );1611}1612} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {1613// Use textContent for elements1614// innerText usage removed for consistency of new lines (jQuery #11153)1615if ( typeof elem.textContent === "string" ) {1616return elem.textContent;1617} else {1618// Traverse its children1619for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {1620ret += getText( elem );1621}1622}1623} else if ( nodeType === 3 || nodeType === 4 ) {1624return elem.nodeValue;1625}1626// Do not include comment or processing instruction nodes1627
1628return ret;1629};1630
1631Expr = Sizzle.selectors = {1632
1633// Can be adjusted by the user1634cacheLength: 50,1635
1636createPseudo: markFunction,1637
1638match: matchExpr,1639
1640attrHandle: {},1641
1642find: {},1643
1644relative: {1645">": { dir: "parentNode", first: true },1646" ": { dir: "parentNode" },1647"+": { dir: "previousSibling", first: true },1648"~": { dir: "previousSibling" }1649},1650
1651preFilter: {1652"ATTR": function( match ) {1653match[1] = match[1].replace( runescape, funescape );1654
1655// Move the given value to match[3] whether quoted or unquoted1656match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );1657
1658if ( match[2] === "~=" ) {1659match[3] = " " + match[3] + " ";1660}1661
1662return match.slice( 0, 4 );1663},1664
1665"CHILD": function( match ) {1666/* matches from matchExpr["CHILD"]16671 type (only|nth|...)
16682 what (child|of-type)
16693 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
16704 xn-component of xn+y argument ([+-]?\d*n|)
16715 sign of xn-component
16726 x of xn-component
16737 sign of y-component
16748 y of y-component
1675*/
1676match[1] = match[1].toLowerCase();1677
1678if ( match[1].slice( 0, 3 ) === "nth" ) {1679// nth-* requires argument1680if ( !match[3] ) {1681Sizzle.error( match[0] );1682}1683
1684// numeric x and y parameters for Expr.filter.CHILD1685// remember that false/true cast respectively to 0/11686match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );1687match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );1688
1689// other types prohibit arguments1690} else if ( match[3] ) {1691Sizzle.error( match[0] );1692}1693
1694return match;1695},1696
1697"PSEUDO": function( match ) {1698var excess,1699unquoted = !match[6] && match[2];1700
1701if ( matchExpr["CHILD"].test( match[0] ) ) {1702return null;1703}1704
1705// Accept quoted arguments as-is1706if ( match[3] ) {1707match[2] = match[4] || match[5] || "";1708
1709// Strip excess characters from unquoted arguments1710} else if ( unquoted && rpseudo.test( unquoted ) &&1711// Get excess from tokenize (recursively)1712(excess = tokenize( unquoted, true )) &&1713// advance to the next closing parenthesis1714(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {1715
1716// excess is a negative index1717match[0] = match[0].slice( 0, excess );1718match[2] = unquoted.slice( 0, excess );1719}1720
1721// Return only captures needed by the pseudo filter method (type and argument)1722return match.slice( 0, 3 );1723}1724},1725
1726filter: {1727
1728"TAG": function( nodeNameSelector ) {1729var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();1730return nodeNameSelector === "*" ?1731function() { return true; } :1732function( elem ) {1733return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;1734};1735},1736
1737"CLASS": function( className ) {1738var pattern = classCache[ className + " " ];1739
1740return pattern ||1741(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&1742classCache( className, function( elem ) {1743return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );1744});1745},1746
1747"ATTR": function( name, operator, check ) {1748return function( elem ) {1749var result = Sizzle.attr( elem, name );1750
1751if ( result == null ) {1752return operator === "!=";1753}1754if ( !operator ) {1755return true;1756}1757
1758result += "";1759
1760return operator === "=" ? result === check :1761operator === "!=" ? result !== check :1762operator === "^=" ? check && result.indexOf( check ) === 0 :1763operator === "*=" ? check && result.indexOf( check ) > -1 :1764operator === "$=" ? check && result.slice( -check.length ) === check :1765operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :1766operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :1767false;1768};1769},1770
1771"CHILD": function( type, what, argument, first, last ) {1772var simple = type.slice( 0, 3 ) !== "nth",1773forward = type.slice( -4 ) !== "last",1774ofType = what === "of-type";1775
1776return first === 1 && last === 0 ?1777
1778// Shortcut for :nth-*(n)1779function( elem ) {1780return !!elem.parentNode;1781} :1782
1783function( elem, context, xml ) {1784var cache, uniqueCache, outerCache, node, nodeIndex, start,1785dir = simple !== forward ? "nextSibling" : "previousSibling",1786parent = elem.parentNode,1787name = ofType && elem.nodeName.toLowerCase(),1788useCache = !xml && !ofType,1789diff = false;1790
1791if ( parent ) {1792
1793// :(first|last|only)-(child|of-type)1794if ( simple ) {1795while ( dir ) {1796node = elem;1797while ( (node = node[ dir ]) ) {1798if ( ofType ?1799node.nodeName.toLowerCase() === name :1800node.nodeType === 1 ) {1801
1802return false;1803}1804}1805// Reverse direction for :only-* (if we haven't yet done so)1806start = dir = type === "only" && !start && "nextSibling";1807}1808return true;1809}1810
1811start = [ forward ? parent.firstChild : parent.lastChild ];1812
1813// non-xml :nth-child(...) stores cache data on `parent`1814if ( forward && useCache ) {1815
1816// Seek `elem` from a previously-cached index1817
1818// ...in a gzip-friendly way1819node = parent;1820outerCache = node[ expando ] || (node[ expando ] = {});1821
1822// Support: IE <9 only1823// Defend against cloned attroperties (jQuery gh-1709)1824uniqueCache = outerCache[ node.uniqueID ] ||1825(outerCache[ node.uniqueID ] = {});1826
1827cache = uniqueCache[ type ] || [];1828nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];1829diff = nodeIndex && cache[ 2 ];1830node = nodeIndex && parent.childNodes[ nodeIndex ];1831
1832while ( (node = ++nodeIndex && node && node[ dir ] ||1833
1834// Fallback to seeking `elem` from the start1835(diff = nodeIndex = 0) || start.pop()) ) {1836
1837// When found, cache indexes on `parent` and break1838if ( node.nodeType === 1 && ++diff && node === elem ) {1839uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];1840break;1841}1842}1843
1844} else {1845// Use previously-cached element index if available1846if ( useCache ) {1847// ...in a gzip-friendly way1848node = elem;1849outerCache = node[ expando ] || (node[ expando ] = {});1850
1851// Support: IE <9 only1852// Defend against cloned attroperties (jQuery gh-1709)1853uniqueCache = outerCache[ node.uniqueID ] ||1854(outerCache[ node.uniqueID ] = {});1855
1856cache = uniqueCache[ type ] || [];1857nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];1858diff = nodeIndex;1859}1860
1861// xml :nth-child(...)1862// or :nth-last-child(...) or :nth(-last)?-of-type(...)1863if ( diff === false ) {1864// Use the same loop as above to seek `elem` from the start1865while ( (node = ++nodeIndex && node && node[ dir ] ||1866(diff = nodeIndex = 0) || start.pop()) ) {1867
1868if ( ( ofType ?1869node.nodeName.toLowerCase() === name :1870node.nodeType === 1 ) &&1871++diff ) {1872
1873// Cache the index of each encountered element1874if ( useCache ) {1875outerCache = node[ expando ] || (node[ expando ] = {});1876
1877// Support: IE <9 only1878// Defend against cloned attroperties (jQuery gh-1709)1879uniqueCache = outerCache[ node.uniqueID ] ||1880(outerCache[ node.uniqueID ] = {});1881
1882uniqueCache[ type ] = [ dirruns, diff ];1883}1884
1885if ( node === elem ) {1886break;1887}1888}1889}1890}1891}1892
1893// Incorporate the offset, then check against cycle size1894diff -= last;1895return diff === first || ( diff % first === 0 && diff / first >= 0 );1896}1897};1898},1899
1900"PSEUDO": function( pseudo, argument ) {1901// pseudo-class names are case-insensitive1902// http://www.w3.org/TR/selectors/#pseudo-classes1903// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters1904// Remember that setFilters inherits from pseudos1905var args,1906fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||1907Sizzle.error( "unsupported pseudo: " + pseudo );1908
1909// The user may use createPseudo to indicate that1910// arguments are needed to create the filter function1911// just as Sizzle does1912if ( fn[ expando ] ) {1913return fn( argument );1914}1915
1916// But maintain support for old signatures1917if ( fn.length > 1 ) {1918args = [ pseudo, pseudo, "", argument ];1919return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?1920markFunction(function( seed, matches ) {1921var idx,1922matched = fn( seed, argument ),1923i = matched.length;1924while ( i-- ) {1925idx = indexOf( seed, matched[i] );1926seed[ idx ] = !( matches[ idx ] = matched[i] );1927}1928}) :1929function( elem ) {1930return fn( elem, 0, args );1931};1932}1933
1934return fn;1935}1936},1937
1938pseudos: {1939// Potentially complex pseudos1940"not": markFunction(function( selector ) {1941// Trim the selector passed to compile1942// to avoid treating leading and trailing1943// spaces as combinators1944var input = [],1945results = [],1946matcher = compile( selector.replace( rtrim, "$1" ) );1947
1948return matcher[ expando ] ?1949markFunction(function( seed, matches, context, xml ) {1950var elem,1951unmatched = matcher( seed, null, xml, [] ),1952i = seed.length;1953
1954// Match elements unmatched by `matcher`1955while ( i-- ) {1956if ( (elem = unmatched[i]) ) {1957seed[i] = !(matches[i] = elem);1958}1959}1960}) :1961function( elem, context, xml ) {1962input[0] = elem;1963matcher( input, null, xml, results );1964// Don't keep the element (issue #299)1965input[0] = null;1966return !results.pop();1967};1968}),1969
1970"has": markFunction(function( selector ) {1971return function( elem ) {1972return Sizzle( selector, elem ).length > 0;1973};1974}),1975
1976"contains": markFunction(function( text ) {1977text = text.replace( runescape, funescape );1978return function( elem ) {1979return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;1980};1981}),1982
1983// "Whether an element is represented by a :lang() selector1984// is based solely on the element's language value1985// being equal to the identifier C,1986// or beginning with the identifier C immediately followed by "-".1987// The matching of C against the element's language value is performed case-insensitively.1988// The identifier C does not have to be a valid language name."1989// http://www.w3.org/TR/selectors/#lang-pseudo1990"lang": markFunction( function( lang ) {1991// lang value must be a valid identifier1992if ( !ridentifier.test(lang || "") ) {1993Sizzle.error( "unsupported lang: " + lang );1994}1995lang = lang.replace( runescape, funescape ).toLowerCase();1996return function( elem ) {1997var elemLang;1998do {1999if ( (elemLang = documentIsHTML ?2000elem.lang :2001elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {2002
2003elemLang = elemLang.toLowerCase();2004return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;2005}2006} while ( (elem = elem.parentNode) && elem.nodeType === 1 );2007return false;2008};2009}),2010
2011// Miscellaneous2012"target": function( elem ) {2013var hash = window.location && window.location.hash;2014return hash && hash.slice( 1 ) === elem.id;2015},2016
2017"root": function( elem ) {2018return elem === docElem;2019},2020
2021"focus": function( elem ) {2022return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);2023},2024
2025// Boolean properties2026"enabled": createDisabledPseudo( false ),2027"disabled": createDisabledPseudo( true ),2028
2029"checked": function( elem ) {2030// In CSS3, :checked should return both checked and selected elements2031// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked2032var nodeName = elem.nodeName.toLowerCase();2033return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);2034},2035
2036"selected": function( elem ) {2037// Accessing this property makes selected-by-default2038// options in Safari work properly2039if ( elem.parentNode ) {2040elem.parentNode.selectedIndex;2041}2042
2043return elem.selected === true;2044},2045
2046// Contents2047"empty": function( elem ) {2048// http://www.w3.org/TR/selectors/#empty-pseudo2049// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),2050// but not by others (comment: 8; processing instruction: 7; etc.)2051// nodeType < 6 works because attributes (2) do not appear as children2052for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {2053if ( elem.nodeType < 6 ) {2054return false;2055}2056}2057return true;2058},2059
2060"parent": function( elem ) {2061return !Expr.pseudos["empty"]( elem );2062},2063
2064// Element/input types2065"header": function( elem ) {2066return rheader.test( elem.nodeName );2067},2068
2069"input": function( elem ) {2070return rinputs.test( elem.nodeName );2071},2072
2073"button": function( elem ) {2074var name = elem.nodeName.toLowerCase();2075return name === "input" && elem.type === "button" || name === "button";2076},2077
2078"text": function( elem ) {2079var attr;2080return elem.nodeName.toLowerCase() === "input" &&2081elem.type === "text" &&2082
2083// Support: IE<82084// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"2085( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );2086},2087
2088// Position-in-collection2089"first": createPositionalPseudo(function() {2090return [ 0 ];2091}),2092
2093"last": createPositionalPseudo(function( matchIndexes, length ) {2094return [ length - 1 ];2095}),2096
2097"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {2098return [ argument < 0 ? argument + length : argument ];2099}),2100
2101"even": createPositionalPseudo(function( matchIndexes, length ) {2102var i = 0;2103for ( ; i < length; i += 2 ) {2104matchIndexes.push( i );2105}2106return matchIndexes;2107}),2108
2109"odd": createPositionalPseudo(function( matchIndexes, length ) {2110var i = 1;2111for ( ; i < length; i += 2 ) {2112matchIndexes.push( i );2113}2114return matchIndexes;2115}),2116
2117"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {2118var i = argument < 0 ?2119argument + length :2120argument > length ?2121length :2122argument;2123for ( ; --i >= 0; ) {2124matchIndexes.push( i );2125}2126return matchIndexes;2127}),2128
2129"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {2130var i = argument < 0 ? argument + length : argument;2131for ( ; ++i < length; ) {2132matchIndexes.push( i );2133}2134return matchIndexes;2135})2136}2137};2138
2139Expr.pseudos["nth"] = Expr.pseudos["eq"];2140
2141// Add button/input type pseudos
2142for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {2143Expr.pseudos[ i ] = createInputPseudo( i );2144}
2145for ( i in { submit: true, reset: true } ) {2146Expr.pseudos[ i ] = createButtonPseudo( i );2147}
2148
2149// Easy API for creating new setFilters
2150function setFilters() {}2151setFilters.prototype = Expr.filters = Expr.pseudos;2152Expr.setFilters = new setFilters();2153
2154tokenize = Sizzle.tokenize = function( selector, parseOnly ) {2155var matched, match, tokens, type,2156soFar, groups, preFilters,2157cached = tokenCache[ selector + " " ];2158
2159if ( cached ) {2160return parseOnly ? 0 : cached.slice( 0 );2161}2162
2163soFar = selector;2164groups = [];2165preFilters = Expr.preFilter;2166
2167while ( soFar ) {2168
2169// Comma and first run2170if ( !matched || (match = rcomma.exec( soFar )) ) {2171if ( match ) {2172// Don't consume trailing commas as valid2173soFar = soFar.slice( match[0].length ) || soFar;2174}2175groups.push( (tokens = []) );2176}2177
2178matched = false;2179
2180// Combinators2181if ( (match = rcombinators.exec( soFar )) ) {2182matched = match.shift();2183tokens.push({2184value: matched,2185// Cast descendant combinators to space2186type: match[0].replace( rtrim, " " )2187});2188soFar = soFar.slice( matched.length );2189}2190
2191// Filters2192for ( type in Expr.filter ) {2193if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||2194(match = preFilters[ type ]( match ))) ) {2195matched = match.shift();2196tokens.push({2197value: matched,2198type: type,2199matches: match2200});2201soFar = soFar.slice( matched.length );2202}2203}2204
2205if ( !matched ) {2206break;2207}2208}2209
2210// Return the length of the invalid excess2211// if we're just parsing2212// Otherwise, throw an error or return tokens2213return parseOnly ?2214soFar.length :2215soFar ?2216Sizzle.error( selector ) :2217// Cache the tokens2218tokenCache( selector, groups ).slice( 0 );2219};2220
2221function toSelector( tokens ) {2222var i = 0,2223len = tokens.length,2224selector = "";2225for ( ; i < len; i++ ) {2226selector += tokens[i].value;2227}2228return selector;2229}
2230
2231function addCombinator( matcher, combinator, base ) {2232var dir = combinator.dir,2233skip = combinator.next,2234key = skip || dir,2235checkNonElements = base && key === "parentNode",2236doneName = done++;2237
2238return combinator.first ?2239// Check against closest ancestor/preceding element2240function( elem, context, xml ) {2241while ( (elem = elem[ dir ]) ) {2242if ( elem.nodeType === 1 || checkNonElements ) {2243return matcher( elem, context, xml );2244}2245}2246return false;2247} :2248
2249// Check against all ancestor/preceding elements2250function( elem, context, xml ) {2251var oldCache, uniqueCache, outerCache,2252newCache = [ dirruns, doneName ];2253
2254// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching2255if ( xml ) {2256while ( (elem = elem[ dir ]) ) {2257if ( elem.nodeType === 1 || checkNonElements ) {2258if ( matcher( elem, context, xml ) ) {2259return true;2260}2261}2262}2263} else {2264while ( (elem = elem[ dir ]) ) {2265if ( elem.nodeType === 1 || checkNonElements ) {2266outerCache = elem[ expando ] || (elem[ expando ] = {});2267
2268// Support: IE <9 only2269// Defend against cloned attroperties (jQuery gh-1709)2270uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});2271
2272if ( skip && skip === elem.nodeName.toLowerCase() ) {2273elem = elem[ dir ] || elem;2274} else if ( (oldCache = uniqueCache[ key ]) &&2275oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {2276
2277// Assign to newCache so results back-propagate to previous elements2278return (newCache[ 2 ] = oldCache[ 2 ]);2279} else {2280// Reuse newcache so results back-propagate to previous elements2281uniqueCache[ key ] = newCache;2282
2283// A match means we're done; a fail means we have to keep checking2284if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {2285return true;2286}2287}2288}2289}2290}2291return false;2292};2293}
2294
2295function elementMatcher( matchers ) {2296return matchers.length > 1 ?2297function( elem, context, xml ) {2298var i = matchers.length;2299while ( i-- ) {2300if ( !matchers[i]( elem, context, xml ) ) {2301return false;2302}2303}2304return true;2305} :2306matchers[0];2307}
2308
2309function multipleContexts( selector, contexts, results ) {2310var i = 0,2311len = contexts.length;2312for ( ; i < len; i++ ) {2313Sizzle( selector, contexts[i], results );2314}2315return results;2316}
2317
2318function condense( unmatched, map, filter, context, xml ) {2319var elem,2320newUnmatched = [],2321i = 0,2322len = unmatched.length,2323mapped = map != null;2324
2325for ( ; i < len; i++ ) {2326if ( (elem = unmatched[i]) ) {2327if ( !filter || filter( elem, context, xml ) ) {2328newUnmatched.push( elem );2329if ( mapped ) {2330map.push( i );2331}2332}2333}2334}2335
2336return newUnmatched;2337}
2338
2339function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {2340if ( postFilter && !postFilter[ expando ] ) {2341postFilter = setMatcher( postFilter );2342}2343if ( postFinder && !postFinder[ expando ] ) {2344postFinder = setMatcher( postFinder, postSelector );2345}2346return markFunction(function( seed, results, context, xml ) {2347var temp, i, elem,2348preMap = [],2349postMap = [],2350preexisting = results.length,2351
2352// Get initial elements from seed or context2353elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),2354
2355// Prefilter to get matcher input, preserving a map for seed-results synchronization2356matcherIn = preFilter && ( seed || !selector ) ?2357condense( elems, preMap, preFilter, context, xml ) :2358elems,2359
2360matcherOut = matcher ?2361// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,2362postFinder || ( seed ? preFilter : preexisting || postFilter ) ?2363
2364// ...intermediate processing is necessary2365[] :2366
2367// ...otherwise use results directly2368results :2369matcherIn;2370
2371// Find primary matches2372if ( matcher ) {2373matcher( matcherIn, matcherOut, context, xml );2374}2375
2376// Apply postFilter2377if ( postFilter ) {2378temp = condense( matcherOut, postMap );2379postFilter( temp, [], context, xml );2380
2381// Un-match failing elements by moving them back to matcherIn2382i = temp.length;2383while ( i-- ) {2384if ( (elem = temp[i]) ) {2385matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);2386}2387}2388}2389
2390if ( seed ) {2391if ( postFinder || preFilter ) {2392if ( postFinder ) {2393// Get the final matcherOut by condensing this intermediate into postFinder contexts2394temp = [];2395i = matcherOut.length;2396while ( i-- ) {2397if ( (elem = matcherOut[i]) ) {2398// Restore matcherIn since elem is not yet a final match2399temp.push( (matcherIn[i] = elem) );2400}2401}2402postFinder( null, (matcherOut = []), temp, xml );2403}2404
2405// Move matched elements from seed to results to keep them synchronized2406i = matcherOut.length;2407while ( i-- ) {2408if ( (elem = matcherOut[i]) &&2409(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {2410
2411seed[temp] = !(results[temp] = elem);2412}2413}2414}2415
2416// Add elements to results, through postFinder if defined2417} else {2418matcherOut = condense(2419matcherOut === results ?2420matcherOut.splice( preexisting, matcherOut.length ) :2421matcherOut
2422);2423if ( postFinder ) {2424postFinder( null, results, matcherOut, xml );2425} else {2426push.apply( results, matcherOut );2427}2428}2429});2430}
2431
2432function matcherFromTokens( tokens ) {2433var checkContext, matcher, j,2434len = tokens.length,2435leadingRelative = Expr.relative[ tokens[0].type ],2436implicitRelative = leadingRelative || Expr.relative[" "],2437i = leadingRelative ? 1 : 0,2438
2439// The foundational matcher ensures that elements are reachable from top-level context(s)2440matchContext = addCombinator( function( elem ) {2441return elem === checkContext;2442}, implicitRelative, true ),2443matchAnyContext = addCombinator( function( elem ) {2444return indexOf( checkContext, elem ) > -1;2445}, implicitRelative, true ),2446matchers = [ function( elem, context, xml ) {2447var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (2448(checkContext = context).nodeType ?2449matchContext( elem, context, xml ) :2450matchAnyContext( elem, context, xml ) );2451// Avoid hanging onto element (issue #299)2452checkContext = null;2453return ret;2454} ];2455
2456for ( ; i < len; i++ ) {2457if ( (matcher = Expr.relative[ tokens[i].type ]) ) {2458matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];2459} else {2460matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );2461
2462// Return special upon seeing a positional matcher2463if ( matcher[ expando ] ) {2464// Find the next relative operator (if any) for proper handling2465j = ++i;2466for ( ; j < len; j++ ) {2467if ( Expr.relative[ tokens[j].type ] ) {2468break;2469}2470}2471return setMatcher(2472i > 1 && elementMatcher( matchers ),2473i > 1 && toSelector(2474// If the preceding token was a descendant combinator, insert an implicit any-element `*`2475tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })2476).replace( rtrim, "$1" ),2477matcher,2478i < j && matcherFromTokens( tokens.slice( i, j ) ),2479j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),2480j < len && toSelector( tokens )2481);2482}2483matchers.push( matcher );2484}2485}2486
2487return elementMatcher( matchers );2488}
2489
2490function matcherFromGroupMatchers( elementMatchers, setMatchers ) {2491var bySet = setMatchers.length > 0,2492byElement = elementMatchers.length > 0,2493superMatcher = function( seed, context, xml, results, outermost ) {2494var elem, j, matcher,2495matchedCount = 0,2496i = "0",2497unmatched = seed && [],2498setMatched = [],2499contextBackup = outermostContext,2500// We must always have either seed elements or outermost context2501elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),2502// Use integer dirruns iff this is the outermost matcher2503dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),2504len = elems.length;2505
2506if ( outermost ) {2507outermostContext = context === document || context || outermost;2508}2509
2510// Add elements passing elementMatchers directly to results2511// Support: IE<9, Safari2512// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id2513for ( ; i !== len && (elem = elems[i]) != null; i++ ) {2514if ( byElement && elem ) {2515j = 0;2516if ( !context && elem.ownerDocument !== document ) {2517setDocument( elem );2518xml = !documentIsHTML;2519}2520while ( (matcher = elementMatchers[j++]) ) {2521if ( matcher( elem, context || document, xml) ) {2522results.push( elem );2523break;2524}2525}2526if ( outermost ) {2527dirruns = dirrunsUnique;2528}2529}2530
2531// Track unmatched elements for set filters2532if ( bySet ) {2533// They will have gone through all possible matchers2534if ( (elem = !matcher && elem) ) {2535matchedCount--;2536}2537
2538// Lengthen the array for every element, matched or not2539if ( seed ) {2540unmatched.push( elem );2541}2542}2543}2544
2545// `i` is now the count of elements visited above, and adding it to `matchedCount`2546// makes the latter nonnegative.2547matchedCount += i;2548
2549// Apply set filters to unmatched elements2550// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`2551// equals `i`), unless we didn't visit _any_ elements in the above loop because we have2552// no element matchers and no seed.2553// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that2554// case, which will result in a "00" `matchedCount` that differs from `i` but is also2555// numerically zero.2556if ( bySet && i !== matchedCount ) {2557j = 0;2558while ( (matcher = setMatchers[j++]) ) {2559matcher( unmatched, setMatched, context, xml );2560}2561
2562if ( seed ) {2563// Reintegrate element matches to eliminate the need for sorting2564if ( matchedCount > 0 ) {2565while ( i-- ) {2566if ( !(unmatched[i] || setMatched[i]) ) {2567setMatched[i] = pop.call( results );2568}2569}2570}2571
2572// Discard index placeholder values to get only actual matches2573setMatched = condense( setMatched );2574}2575
2576// Add matches to results2577push.apply( results, setMatched );2578
2579// Seedless set matches succeeding multiple successful matchers stipulate sorting2580if ( outermost && !seed && setMatched.length > 0 &&2581( matchedCount + setMatchers.length ) > 1 ) {2582
2583Sizzle.uniqueSort( results );2584}2585}2586
2587// Override manipulation of globals by nested matchers2588if ( outermost ) {2589dirruns = dirrunsUnique;2590outermostContext = contextBackup;2591}2592
2593return unmatched;2594};2595
2596return bySet ?2597markFunction( superMatcher ) :2598superMatcher;2599}
2600
2601compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {2602var i,2603setMatchers = [],2604elementMatchers = [],2605cached = compilerCache[ selector + " " ];2606
2607if ( !cached ) {2608// Generate a function of recursive functions that can be used to check each element2609if ( !match ) {2610match = tokenize( selector );2611}2612i = match.length;2613while ( i-- ) {2614cached = matcherFromTokens( match[i] );2615if ( cached[ expando ] ) {2616setMatchers.push( cached );2617} else {2618elementMatchers.push( cached );2619}2620}2621
2622// Cache the compiled function2623cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );2624
2625// Save selector and tokenization2626cached.selector = selector;2627}2628return cached;2629};2630
2631/**
2632* A low-level selection function that works with Sizzle's compiled
2633* selector functions
2634* @param {String|Function} selector A selector or a pre-compiled
2635* selector function built with Sizzle.compile
2636* @param {Element} context
2637* @param {Array} [results]
2638* @param {Array} [seed] A set of elements to match against
2639*/
2640select = Sizzle.select = function( selector, context, results, seed ) {2641var i, tokens, token, type, find,2642compiled = typeof selector === "function" && selector,2643match = !seed && tokenize( (selector = compiled.selector || selector) );2644
2645results = results || [];2646
2647// Try to minimize operations if there is only one selector in the list and no seed2648// (the latter of which guarantees us context)2649if ( match.length === 1 ) {2650
2651// Reduce context if the leading compound selector is an ID2652tokens = match[0] = match[0].slice( 0 );2653if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&2654context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {2655
2656context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];2657if ( !context ) {2658return results;2659
2660// Precompiled matchers will still verify ancestry, so step up a level2661} else if ( compiled ) {2662context = context.parentNode;2663}2664
2665selector = selector.slice( tokens.shift().value.length );2666}2667
2668// Fetch a seed set for right-to-left matching2669i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;2670while ( i-- ) {2671token = tokens[i];2672
2673// Abort if we hit a combinator2674if ( Expr.relative[ (type = token.type) ] ) {2675break;2676}2677if ( (find = Expr.find[ type ]) ) {2678// Search, expanding context for leading sibling combinators2679if ( (seed = find(2680token.matches[0].replace( runescape, funescape ),2681rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context2682)) ) {2683
2684// If seed is empty or no tokens remain, we can return early2685tokens.splice( i, 1 );2686selector = seed.length && toSelector( tokens );2687if ( !selector ) {2688push.apply( results, seed );2689return results;2690}2691
2692break;2693}2694}2695}2696}2697
2698// Compile and execute a filtering function if one is not provided2699// Provide `match` to avoid retokenization if we modified the selector above2700( compiled || compile( selector, match ) )(2701seed,2702context,2703!documentIsHTML,2704results,2705!context || rsibling.test( selector ) && testContext( context.parentNode ) || context2706);2707return results;2708};2709
2710// One-time assignments
2711
2712// Sort stability
2713support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;2714
2715// Support: Chrome 14-35+
2716// Always assume duplicates if they aren't passed to the comparison function
2717support.detectDuplicates = !!hasDuplicate;2718
2719// Initialize against the default document
2720setDocument();2721
2722// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2723// Detached nodes confoundingly follow *each other*
2724support.sortDetached = assert(function( el ) {2725// Should return 1, but returns 4 (following)2726return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;2727});2728
2729// Support: IE<8
2730// Prevent attribute/property "interpolation"
2731// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2732if ( !assert(function( el ) {2733el.innerHTML = "<a href='#'></a>";2734return el.firstChild.getAttribute("href") === "#" ;2735}) ) {2736addHandle( "type|href|height|width", function( elem, name, isXML ) {2737if ( !isXML ) {2738return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );2739}2740});2741}
2742
2743// Support: IE<9
2744// Use defaultValue in place of getAttribute("value")
2745if ( !support.attributes || !assert(function( el ) {2746el.innerHTML = "<input/>";2747el.firstChild.setAttribute( "value", "" );2748return el.firstChild.getAttribute( "value" ) === "";2749}) ) {2750addHandle( "value", function( elem, name, isXML ) {2751if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {2752return elem.defaultValue;2753}2754});2755}
2756
2757// Support: IE<9
2758// Use getAttributeNode to fetch booleans when getAttribute lies
2759if ( !assert(function( el ) {2760return el.getAttribute("disabled") == null;2761}) ) {2762addHandle( booleans, function( elem, name, isXML ) {2763var val;2764if ( !isXML ) {2765return elem[ name ] === true ? name.toLowerCase() :2766(val = elem.getAttributeNode( name )) && val.specified ?2767val.value :2768null;2769}2770});2771}
2772
2773return Sizzle;2774
2775})( window );2776
2777
2778
2779jQuery.find = Sizzle;2780jQuery.expr = Sizzle.selectors;2781
2782// Deprecated
2783jQuery.expr[ ":" ] = jQuery.expr.pseudos;2784jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;2785jQuery.text = Sizzle.getText;2786jQuery.isXMLDoc = Sizzle.isXML;2787jQuery.contains = Sizzle.contains;2788jQuery.escapeSelector = Sizzle.escape;2789
2790
2791
2792
2793var dir = function( elem, dir, until ) {2794var matched = [],2795truncate = until !== undefined;2796
2797while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {2798if ( elem.nodeType === 1 ) {2799if ( truncate && jQuery( elem ).is( until ) ) {2800break;2801}2802matched.push( elem );2803}2804}2805return matched;2806};2807
2808
2809var siblings = function( n, elem ) {2810var matched = [];2811
2812for ( ; n; n = n.nextSibling ) {2813if ( n.nodeType === 1 && n !== elem ) {2814matched.push( n );2815}2816}2817
2818return matched;2819};2820
2821
2822var rneedsContext = jQuery.expr.match.needsContext;2823
2824
2825
2826function nodeName( elem, name ) {2827
2828return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();2829
2830};2831var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );2832
2833
2834
2835// Implement the identical functionality for filter and not
2836function winnow( elements, qualifier, not ) {2837if ( isFunction( qualifier ) ) {2838return jQuery.grep( elements, function( elem, i ) {2839return !!qualifier.call( elem, i, elem ) !== not;2840} );2841}2842
2843// Single element2844if ( qualifier.nodeType ) {2845return jQuery.grep( elements, function( elem ) {2846return ( elem === qualifier ) !== not;2847} );2848}2849
2850// Arraylike of elements (jQuery, arguments, Array)2851if ( typeof qualifier !== "string" ) {2852return jQuery.grep( elements, function( elem ) {2853return ( indexOf.call( qualifier, elem ) > -1 ) !== not;2854} );2855}2856
2857// Filtered directly for both simple and complex selectors2858return jQuery.filter( qualifier, elements, not );2859}
2860
2861jQuery.filter = function( expr, elems, not ) {2862var elem = elems[ 0 ];2863
2864if ( not ) {2865expr = ":not(" + expr + ")";2866}2867
2868if ( elems.length === 1 && elem.nodeType === 1 ) {2869return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];2870}2871
2872return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {2873return elem.nodeType === 1;2874} ) );2875};2876
2877jQuery.fn.extend( {2878find: function( selector ) {2879var i, ret,2880len = this.length,2881self = this;2882
2883if ( typeof selector !== "string" ) {2884return this.pushStack( jQuery( selector ).filter( function() {2885for ( i = 0; i < len; i++ ) {2886if ( jQuery.contains( self[ i ], this ) ) {2887return true;2888}2889}2890} ) );2891}2892
2893ret = this.pushStack( [] );2894
2895for ( i = 0; i < len; i++ ) {2896jQuery.find( selector, self[ i ], ret );2897}2898
2899return len > 1 ? jQuery.uniqueSort( ret ) : ret;2900},2901filter: function( selector ) {2902return this.pushStack( winnow( this, selector || [], false ) );2903},2904not: function( selector ) {2905return this.pushStack( winnow( this, selector || [], true ) );2906},2907is: function( selector ) {2908return !!winnow(2909this,2910
2911// If this is a positional/relative selector, check membership in the returned set2912// so $("p:first").is("p:last") won't return true for a doc with two "p".2913typeof selector === "string" && rneedsContext.test( selector ) ?2914jQuery( selector ) :2915selector || [],2916false2917).length;2918}2919} );2920
2921
2922// Initialize a jQuery object
2923
2924
2925// A central reference to the root jQuery(document)
2926var rootjQuery,2927
2928// A simple way to check for HTML strings2929// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)2930// Strict HTML recognition (#11290: must start with <)2931// Shortcut simple #id case for speed2932rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,2933
2934init = jQuery.fn.init = function( selector, context, root ) {2935var match, elem;2936
2937// HANDLE: $(""), $(null), $(undefined), $(false)2938if ( !selector ) {2939return this;2940}2941
2942// Method init() accepts an alternate rootjQuery2943// so migrate can support jQuery.sub (gh-2101)2944root = root || rootjQuery;2945
2946// Handle HTML strings2947if ( typeof selector === "string" ) {2948if ( selector[ 0 ] === "<" &&2949selector[ selector.length - 1 ] === ">" &&2950selector.length >= 3 ) {2951
2952// Assume that strings that start and end with <> are HTML and skip the regex check2953match = [ null, selector, null ];2954
2955} else {2956match = rquickExpr.exec( selector );2957}2958
2959// Match html or make sure no context is specified for #id2960if ( match && ( match[ 1 ] || !context ) ) {2961
2962// HANDLE: $(html) -> $(array)2963if ( match[ 1 ] ) {2964context = context instanceof jQuery ? context[ 0 ] : context;2965
2966// Option to run scripts is true for back-compat2967// Intentionally let the error be thrown if parseHTML is not present2968jQuery.merge( this, jQuery.parseHTML(2969match[ 1 ],2970context && context.nodeType ? context.ownerDocument || context : document,2971true2972) );2973
2974// HANDLE: $(html, props)2975if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {2976for ( match in context ) {2977
2978// Properties of context are called as methods if possible2979if ( isFunction( this[ match ] ) ) {2980this[ match ]( context[ match ] );2981
2982// ...and otherwise set as attributes2983} else {2984this.attr( match, context[ match ] );2985}2986}2987}2988
2989return this;2990
2991// HANDLE: $(#id)2992} else {2993elem = document.getElementById( match[ 2 ] );2994
2995if ( elem ) {2996
2997// Inject the element directly into the jQuery object2998this[ 0 ] = elem;2999this.length = 1;3000}3001return this;3002}3003
3004// HANDLE: $(expr, $(...))3005} else if ( !context || context.jquery ) {3006return ( context || root ).find( selector );3007
3008// HANDLE: $(expr, context)3009// (which is just equivalent to: $(context).find(expr)3010} else {3011return this.constructor( context ).find( selector );3012}3013
3014// HANDLE: $(DOMElement)3015} else if ( selector.nodeType ) {3016this[ 0 ] = selector;3017this.length = 1;3018return this;3019
3020// HANDLE: $(function)3021// Shortcut for document ready3022} else if ( isFunction( selector ) ) {3023return root.ready !== undefined ?3024root.ready( selector ) :3025
3026// Execute immediately if ready is not present3027selector( jQuery );3028}3029
3030return jQuery.makeArray( selector, this );3031};3032
3033// Give the init function the jQuery prototype for later instantiation
3034init.prototype = jQuery.fn;3035
3036// Initialize central reference
3037rootjQuery = jQuery( document );3038
3039
3040var rparentsprev = /^(?:parents|prev(?:Until|All))/,3041
3042// Methods guaranteed to produce a unique set when starting from a unique set3043guaranteedUnique = {3044children: true,3045contents: true,3046next: true,3047prev: true3048};3049
3050jQuery.fn.extend( {3051has: function( target ) {3052var targets = jQuery( target, this ),3053l = targets.length;3054
3055return this.filter( function() {3056var i = 0;3057for ( ; i < l; i++ ) {3058if ( jQuery.contains( this, targets[ i ] ) ) {3059return true;3060}3061}3062} );3063},3064
3065closest: function( selectors, context ) {3066var cur,3067i = 0,3068l = this.length,3069matched = [],3070targets = typeof selectors !== "string" && jQuery( selectors );3071
3072// Positional selectors never match, since there's no _selection_ context3073if ( !rneedsContext.test( selectors ) ) {3074for ( ; i < l; i++ ) {3075for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {3076
3077// Always skip document fragments3078if ( cur.nodeType < 11 && ( targets ?3079targets.index( cur ) > -1 :3080
3081// Don't pass non-elements to Sizzle3082cur.nodeType === 1 &&3083jQuery.find.matchesSelector( cur, selectors ) ) ) {3084
3085matched.push( cur );3086break;3087}3088}3089}3090}3091
3092return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );3093},3094
3095// Determine the position of an element within the set3096index: function( elem ) {3097
3098// No argument, return index in parent3099if ( !elem ) {3100return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;3101}3102
3103// Index in selector3104if ( typeof elem === "string" ) {3105return indexOf.call( jQuery( elem ), this[ 0 ] );3106}3107
3108// Locate the position of the desired element3109return indexOf.call( this,3110
3111// If it receives a jQuery object, the first element is used3112elem.jquery ? elem[ 0 ] : elem3113);3114},3115
3116add: function( selector, context ) {3117return this.pushStack(3118jQuery.uniqueSort(3119jQuery.merge( this.get(), jQuery( selector, context ) )3120)3121);3122},3123
3124addBack: function( selector ) {3125return this.add( selector == null ?3126this.prevObject : this.prevObject.filter( selector )3127);3128}3129} );3130
3131function sibling( cur, dir ) {3132while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}3133return cur;3134}
3135
3136jQuery.each( {3137parent: function( elem ) {3138var parent = elem.parentNode;3139return parent && parent.nodeType !== 11 ? parent : null;3140},3141parents: function( elem ) {3142return dir( elem, "parentNode" );3143},3144parentsUntil: function( elem, i, until ) {3145return dir( elem, "parentNode", until );3146},3147next: function( elem ) {3148return sibling( elem, "nextSibling" );3149},3150prev: function( elem ) {3151return sibling( elem, "previousSibling" );3152},3153nextAll: function( elem ) {3154return dir( elem, "nextSibling" );3155},3156prevAll: function( elem ) {3157return dir( elem, "previousSibling" );3158},3159nextUntil: function( elem, i, until ) {3160return dir( elem, "nextSibling", until );3161},3162prevUntil: function( elem, i, until ) {3163return dir( elem, "previousSibling", until );3164},3165siblings: function( elem ) {3166return siblings( ( elem.parentNode || {} ).firstChild, elem );3167},3168children: function( elem ) {3169return siblings( elem.firstChild );3170},3171contents: function( elem ) {3172if ( typeof elem.contentDocument !== "undefined" ) {3173return elem.contentDocument;3174}3175
3176// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only3177// Treat the template element as a regular one in browsers that3178// don't support it.3179if ( nodeName( elem, "template" ) ) {3180elem = elem.content || elem;3181}3182
3183return jQuery.merge( [], elem.childNodes );3184}3185}, function( name, fn ) {3186jQuery.fn[ name ] = function( until, selector ) {3187var matched = jQuery.map( this, fn, until );3188
3189if ( name.slice( -5 ) !== "Until" ) {3190selector = until;3191}3192
3193if ( selector && typeof selector === "string" ) {3194matched = jQuery.filter( selector, matched );3195}3196
3197if ( this.length > 1 ) {3198
3199// Remove duplicates3200if ( !guaranteedUnique[ name ] ) {3201jQuery.uniqueSort( matched );3202}3203
3204// Reverse order for parents* and prev-derivatives3205if ( rparentsprev.test( name ) ) {3206matched.reverse();3207}3208}3209
3210return this.pushStack( matched );3211};3212} );3213var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );3214
3215
3216
3217// Convert String-formatted options into Object-formatted ones
3218function createOptions( options ) {3219var object = {};3220jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {3221object[ flag ] = true;3222} );3223return object;3224}
3225
3226/*
3227* Create a callback list using the following parameters:
3228*
3229* options: an optional list of space-separated options that will change how
3230* the callback list behaves or a more traditional option object
3231*
3232* By default a callback list will act like an event callback list and can be
3233* "fired" multiple times.
3234*
3235* Possible options:
3236*
3237* once: will ensure the callback list can only be fired once (like a Deferred)
3238*
3239* memory: will keep track of previous values and will call any callback added
3240* after the list has been fired right away with the latest "memorized"
3241* values (like a Deferred)
3242*
3243* unique: will ensure a callback can only be added once (no duplicate in the list)
3244*
3245* stopOnFalse: interrupt callings when a callback returns false
3246*
3247*/
3248jQuery.Callbacks = function( options ) {3249
3250// Convert options from String-formatted to Object-formatted if needed3251// (we check in cache first)3252options = typeof options === "string" ?3253createOptions( options ) :3254jQuery.extend( {}, options );3255
3256var // Flag to know if list is currently firing3257firing,3258
3259// Last fire value for non-forgettable lists3260memory,3261
3262// Flag to know if list was already fired3263fired,3264
3265// Flag to prevent firing3266locked,3267
3268// Actual callback list3269list = [],3270
3271// Queue of execution data for repeatable lists3272queue = [],3273
3274// Index of currently firing callback (modified by add/remove as needed)3275firingIndex = -1,3276
3277// Fire callbacks3278fire = function() {3279
3280// Enforce single-firing3281locked = locked || options.once;3282
3283// Execute callbacks for all pending executions,3284// respecting firingIndex overrides and runtime changes3285fired = firing = true;3286for ( ; queue.length; firingIndex = -1 ) {3287memory = queue.shift();3288while ( ++firingIndex < list.length ) {3289
3290// Run callback and check for early termination3291if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&3292options.stopOnFalse ) {3293
3294// Jump to end and forget the data so .add doesn't re-fire3295firingIndex = list.length;3296memory = false;3297}3298}3299}3300
3301// Forget the data if we're done with it3302if ( !options.memory ) {3303memory = false;3304}3305
3306firing = false;3307
3308// Clean up if we're done firing for good3309if ( locked ) {3310
3311// Keep an empty list if we have data for future add calls3312if ( memory ) {3313list = [];3314
3315// Otherwise, this object is spent3316} else {3317list = "";3318}3319}3320},3321
3322// Actual Callbacks object3323self = {3324
3325// Add a callback or a collection of callbacks to the list3326add: function() {3327if ( list ) {3328
3329// If we have memory from a past run, we should fire after adding3330if ( memory && !firing ) {3331firingIndex = list.length - 1;3332queue.push( memory );3333}3334
3335( function add( args ) {3336jQuery.each( args, function( _, arg ) {3337if ( isFunction( arg ) ) {3338if ( !options.unique || !self.has( arg ) ) {3339list.push( arg );3340}3341} else if ( arg && arg.length && toType( arg ) !== "string" ) {3342
3343// Inspect recursively3344add( arg );3345}3346} );3347} )( arguments );3348
3349if ( memory && !firing ) {3350fire();3351}3352}3353return this;3354},3355
3356// Remove a callback from the list3357remove: function() {3358jQuery.each( arguments, function( _, arg ) {3359var index;3360while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {3361list.splice( index, 1 );3362
3363// Handle firing indexes3364if ( index <= firingIndex ) {3365firingIndex--;3366}3367}3368} );3369return this;3370},3371
3372// Check if a given callback is in the list.3373// If no argument is given, return whether or not list has callbacks attached.3374has: function( fn ) {3375return fn ?3376jQuery.inArray( fn, list ) > -1 :3377list.length > 0;3378},3379
3380// Remove all callbacks from the list3381empty: function() {3382if ( list ) {3383list = [];3384}3385return this;3386},3387
3388// Disable .fire and .add3389// Abort any current/pending executions3390// Clear all callbacks and values3391disable: function() {3392locked = queue = [];3393list = memory = "";3394return this;3395},3396disabled: function() {3397return !list;3398},3399
3400// Disable .fire3401// Also disable .add unless we have memory (since it would have no effect)3402// Abort any pending executions3403lock: function() {3404locked = queue = [];3405if ( !memory && !firing ) {3406list = memory = "";3407}3408return this;3409},3410locked: function() {3411return !!locked;3412},3413
3414// Call all callbacks with the given context and arguments3415fireWith: function( context, args ) {3416if ( !locked ) {3417args = args || [];3418args = [ context, args.slice ? args.slice() : args ];3419queue.push( args );3420if ( !firing ) {3421fire();3422}3423}3424return this;3425},3426
3427// Call all the callbacks with the given arguments3428fire: function() {3429self.fireWith( this, arguments );3430return this;3431},3432
3433// To know if the callbacks have already been called at least once3434fired: function() {3435return !!fired;3436}3437};3438
3439return self;3440};3441
3442
3443function Identity( v ) {3444return v;3445}
3446function Thrower( ex ) {3447throw ex;3448}
3449
3450function adoptValue( value, resolve, reject, noValue ) {3451var method;3452
3453try {3454
3455// Check for promise aspect first to privilege synchronous behavior3456if ( value && isFunction( ( method = value.promise ) ) ) {3457method.call( value ).done( resolve ).fail( reject );3458
3459// Other thenables3460} else if ( value && isFunction( ( method = value.then ) ) ) {3461method.call( value, resolve, reject );3462
3463// Other non-thenables3464} else {3465
3466// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:3467// * false: [ value ].slice( 0 ) => resolve( value )3468// * true: [ value ].slice( 1 ) => resolve()3469resolve.apply( undefined, [ value ].slice( noValue ) );3470}3471
3472// For Promises/A+, convert exceptions into rejections3473// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in3474// Deferred#then to conditionally suppress rejection.3475} catch ( value ) {3476
3477// Support: Android 4.0 only3478// Strict mode functions invoked without .call/.apply get global-object context3479reject.apply( undefined, [ value ] );3480}3481}
3482
3483jQuery.extend( {3484
3485Deferred: function( func ) {3486var tuples = [3487
3488// action, add listener, callbacks,3489// ... .then handlers, argument index, [final state]3490[ "notify", "progress", jQuery.Callbacks( "memory" ),3491jQuery.Callbacks( "memory" ), 2 ],3492[ "resolve", "done", jQuery.Callbacks( "once memory" ),3493jQuery.Callbacks( "once memory" ), 0, "resolved" ],3494[ "reject", "fail", jQuery.Callbacks( "once memory" ),3495jQuery.Callbacks( "once memory" ), 1, "rejected" ]3496],3497state = "pending",3498promise = {3499state: function() {3500return state;3501},3502always: function() {3503deferred.done( arguments ).fail( arguments );3504return this;3505},3506"catch": function( fn ) {3507return promise.then( null, fn );3508},3509
3510// Keep pipe for back-compat3511pipe: function( /* fnDone, fnFail, fnProgress */ ) {3512var fns = arguments;3513
3514return jQuery.Deferred( function( newDefer ) {3515jQuery.each( tuples, function( i, tuple ) {3516
3517// Map tuples (progress, done, fail) to arguments (done, fail, progress)3518var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];3519
3520// deferred.progress(function() { bind to newDefer or newDefer.notify })3521// deferred.done(function() { bind to newDefer or newDefer.resolve })3522// deferred.fail(function() { bind to newDefer or newDefer.reject })3523deferred[ tuple[ 1 ] ]( function() {3524var returned = fn && fn.apply( this, arguments );3525if ( returned && isFunction( returned.promise ) ) {3526returned.promise()3527.progress( newDefer.notify )3528.done( newDefer.resolve )3529.fail( newDefer.reject );3530} else {3531newDefer[ tuple[ 0 ] + "With" ](3532this,3533fn ? [ returned ] : arguments3534);3535}3536} );3537} );3538fns = null;3539} ).promise();3540},3541then: function( onFulfilled, onRejected, onProgress ) {3542var maxDepth = 0;3543function resolve( depth, deferred, handler, special ) {3544return function() {3545var that = this,3546args = arguments,3547mightThrow = function() {3548var returned, then;3549
3550// Support: Promises/A+ section 2.3.3.3.33551// https://promisesaplus.com/#point-593552// Ignore double-resolution attempts3553if ( depth < maxDepth ) {3554return;3555}3556
3557returned = handler.apply( that, args );3558
3559// Support: Promises/A+ section 2.3.13560// https://promisesaplus.com/#point-483561if ( returned === deferred.promise() ) {3562throw new TypeError( "Thenable self-resolution" );3563}3564
3565// Support: Promises/A+ sections 2.3.3.1, 3.53566// https://promisesaplus.com/#point-543567// https://promisesaplus.com/#point-753568// Retrieve `then` only once3569then = returned &&3570
3571// Support: Promises/A+ section 2.3.43572// https://promisesaplus.com/#point-643573// Only check objects and functions for thenability3574( typeof returned === "object" ||3575typeof returned === "function" ) &&3576returned.then;3577
3578// Handle a returned thenable3579if ( isFunction( then ) ) {3580
3581// Special processors (notify) just wait for resolution3582if ( special ) {3583then.call(3584returned,3585resolve( maxDepth, deferred, Identity, special ),3586resolve( maxDepth, deferred, Thrower, special )3587);3588
3589// Normal processors (resolve) also hook into progress3590} else {3591
3592// ...and disregard older resolution values3593maxDepth++;3594
3595then.call(3596returned,3597resolve( maxDepth, deferred, Identity, special ),3598resolve( maxDepth, deferred, Thrower, special ),3599resolve( maxDepth, deferred, Identity,3600deferred.notifyWith )3601);3602}3603
3604// Handle all other returned values3605} else {3606
3607// Only substitute handlers pass on context3608// and multiple values (non-spec behavior)3609if ( handler !== Identity ) {3610that = undefined;3611args = [ returned ];3612}3613
3614// Process the value(s)3615// Default process is resolve3616( special || deferred.resolveWith )( that, args );3617}3618},3619
3620// Only normal processors (resolve) catch and reject exceptions3621process = special ?3622mightThrow :3623function() {3624try {3625mightThrow();3626} catch ( e ) {3627
3628if ( jQuery.Deferred.exceptionHook ) {3629jQuery.Deferred.exceptionHook( e,3630process.stackTrace );3631}3632
3633// Support: Promises/A+ section 2.3.3.3.4.13634// https://promisesaplus.com/#point-613635// Ignore post-resolution exceptions3636if ( depth + 1 >= maxDepth ) {3637
3638// Only substitute handlers pass on context3639// and multiple values (non-spec behavior)3640if ( handler !== Thrower ) {3641that = undefined;3642args = [ e ];3643}3644
3645deferred.rejectWith( that, args );3646}3647}3648};3649
3650// Support: Promises/A+ section 2.3.3.3.13651// https://promisesaplus.com/#point-573652// Re-resolve promises immediately to dodge false rejection from3653// subsequent errors3654if ( depth ) {3655process();3656} else {3657
3658// Call an optional hook to record the stack, in case of exception3659// since it's otherwise lost when execution goes async3660if ( jQuery.Deferred.getStackHook ) {3661process.stackTrace = jQuery.Deferred.getStackHook();3662}3663window.setTimeout( process );3664}3665};3666}3667
3668return jQuery.Deferred( function( newDefer ) {3669
3670// progress_handlers.add( ... )3671tuples[ 0 ][ 3 ].add(3672resolve(36730,3674newDefer,3675isFunction( onProgress ) ?3676onProgress :3677Identity,3678newDefer.notifyWith3679)3680);3681
3682// fulfilled_handlers.add( ... )3683tuples[ 1 ][ 3 ].add(3684resolve(36850,3686newDefer,3687isFunction( onFulfilled ) ?3688onFulfilled :3689Identity
3690)3691);3692
3693// rejected_handlers.add( ... )3694tuples[ 2 ][ 3 ].add(3695resolve(36960,3697newDefer,3698isFunction( onRejected ) ?3699onRejected :3700Thrower
3701)3702);3703} ).promise();3704},3705
3706// Get a promise for this deferred3707// If obj is provided, the promise aspect is added to the object3708promise: function( obj ) {3709return obj != null ? jQuery.extend( obj, promise ) : promise;3710}3711},3712deferred = {};3713
3714// Add list-specific methods3715jQuery.each( tuples, function( i, tuple ) {3716var list = tuple[ 2 ],3717stateString = tuple[ 5 ];3718
3719// promise.progress = list.add3720// promise.done = list.add3721// promise.fail = list.add3722promise[ tuple[ 1 ] ] = list.add;3723
3724// Handle state3725if ( stateString ) {3726list.add(3727function() {3728
3729// state = "resolved" (i.e., fulfilled)3730// state = "rejected"3731state = stateString;3732},3733
3734// rejected_callbacks.disable3735// fulfilled_callbacks.disable3736tuples[ 3 - i ][ 2 ].disable,3737
3738// rejected_handlers.disable3739// fulfilled_handlers.disable3740tuples[ 3 - i ][ 3 ].disable,3741
3742// progress_callbacks.lock3743tuples[ 0 ][ 2 ].lock,3744
3745// progress_handlers.lock3746tuples[ 0 ][ 3 ].lock3747);3748}3749
3750// progress_handlers.fire3751// fulfilled_handlers.fire3752// rejected_handlers.fire3753list.add( tuple[ 3 ].fire );3754
3755// deferred.notify = function() { deferred.notifyWith(...) }3756// deferred.resolve = function() { deferred.resolveWith(...) }3757// deferred.reject = function() { deferred.rejectWith(...) }3758deferred[ tuple[ 0 ] ] = function() {3759deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );3760return this;3761};3762
3763// deferred.notifyWith = list.fireWith3764// deferred.resolveWith = list.fireWith3765// deferred.rejectWith = list.fireWith3766deferred[ tuple[ 0 ] + "With" ] = list.fireWith;3767} );3768
3769// Make the deferred a promise3770promise.promise( deferred );3771
3772// Call given func if any3773if ( func ) {3774func.call( deferred, deferred );3775}3776
3777// All done!3778return deferred;3779},3780
3781// Deferred helper3782when: function( singleValue ) {3783var3784
3785// count of uncompleted subordinates3786remaining = arguments.length,3787
3788// count of unprocessed arguments3789i = remaining,3790
3791// subordinate fulfillment data3792resolveContexts = Array( i ),3793resolveValues = slice.call( arguments ),3794
3795// the master Deferred3796master = jQuery.Deferred(),3797
3798// subordinate callback factory3799updateFunc = function( i ) {3800return function( value ) {3801resolveContexts[ i ] = this;3802resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;3803if ( !( --remaining ) ) {3804master.resolveWith( resolveContexts, resolveValues );3805}3806};3807};3808
3809// Single- and empty arguments are adopted like Promise.resolve3810if ( remaining <= 1 ) {3811adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,3812!remaining );3813
3814// Use .then() to unwrap secondary thenables (cf. gh-3000)3815if ( master.state() === "pending" ||3816isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {3817
3818return master.then();3819}3820}3821
3822// Multiple arguments are aggregated like Promise.all array elements3823while ( i-- ) {3824adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );3825}3826
3827return master.promise();3828}3829} );3830
3831
3832// These usually indicate a programmer mistake during development,
3833// warn about them ASAP rather than swallowing them by default.
3834var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;3835
3836jQuery.Deferred.exceptionHook = function( error, stack ) {3837
3838// Support: IE 8 - 9 only3839// Console exists when dev tools are open, which can happen at any time3840if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {3841window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );3842}3843};3844
3845
3846
3847
3848jQuery.readyException = function( error ) {3849window.setTimeout( function() {3850throw error;3851} );3852};3853
3854
3855
3856
3857// The deferred used on DOM ready
3858var readyList = jQuery.Deferred();3859
3860jQuery.fn.ready = function( fn ) {3861
3862readyList
3863.then( fn )3864
3865// Wrap jQuery.readyException in a function so that the lookup3866// happens at the time of error handling instead of callback3867// registration.3868.catch( function( error ) {3869jQuery.readyException( error );3870} );3871
3872return this;3873};3874
3875jQuery.extend( {3876
3877// Is the DOM ready to be used? Set to true once it occurs.3878isReady: false,3879
3880// A counter to track how many items to wait for before3881// the ready event fires. See #67813882readyWait: 1,3883
3884// Handle when the DOM is ready3885ready: function( wait ) {3886
3887// Abort if there are pending holds or we're already ready3888if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {3889return;3890}3891
3892// Remember that the DOM is ready3893jQuery.isReady = true;3894
3895// If a normal DOM Ready event fired, decrement, and wait if need be3896if ( wait !== true && --jQuery.readyWait > 0 ) {3897return;3898}3899
3900// If there are functions bound, to execute3901readyList.resolveWith( document, [ jQuery ] );3902}3903} );3904
3905jQuery.ready.then = readyList.then;3906
3907// The ready event handler and self cleanup method
3908function completed() {3909document.removeEventListener( "DOMContentLoaded", completed );3910window.removeEventListener( "load", completed );3911jQuery.ready();3912}
3913
3914// Catch cases where $(document).ready() is called
3915// after the browser event has already occurred.
3916// Support: IE <=9 - 10 only
3917// Older IE sometimes signals "interactive" too soon
3918if ( document.readyState === "complete" ||3919( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {3920
3921// Handle it asynchronously to allow scripts the opportunity to delay ready3922window.setTimeout( jQuery.ready );3923
3924} else {3925
3926// Use the handy event callback3927document.addEventListener( "DOMContentLoaded", completed );3928
3929// A fallback to window.onload, that will always work3930window.addEventListener( "load", completed );3931}
3932
3933
3934
3935
3936// Multifunctional method to get and set values of a collection
3937// The value/s can optionally be executed if it's a function
3938var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {3939var i = 0,3940len = elems.length,3941bulk = key == null;3942
3943// Sets many values3944if ( toType( key ) === "object" ) {3945chainable = true;3946for ( i in key ) {3947access( elems, fn, i, key[ i ], true, emptyGet, raw );3948}3949
3950// Sets one value3951} else if ( value !== undefined ) {3952chainable = true;3953
3954if ( !isFunction( value ) ) {3955raw = true;3956}3957
3958if ( bulk ) {3959
3960// Bulk operations run against the entire set3961if ( raw ) {3962fn.call( elems, value );3963fn = null;3964
3965// ...except when executing function values3966} else {3967bulk = fn;3968fn = function( elem, key, value ) {3969return bulk.call( jQuery( elem ), value );3970};3971}3972}3973
3974if ( fn ) {3975for ( ; i < len; i++ ) {3976fn(3977elems[ i ], key, raw ?3978value :3979value.call( elems[ i ], i, fn( elems[ i ], key ) )3980);3981}3982}3983}3984
3985if ( chainable ) {3986return elems;3987}3988
3989// Gets3990if ( bulk ) {3991return fn.call( elems );3992}3993
3994return len ? fn( elems[ 0 ], key ) : emptyGet;3995};3996
3997
3998// Matches dashed string for camelizing
3999var rmsPrefix = /^-ms-/,4000rdashAlpha = /-([a-z])/g;4001
4002// Used by camelCase as callback to replace()
4003function fcamelCase( all, letter ) {4004return letter.toUpperCase();4005}
4006
4007// Convert dashed to camelCase; used by the css and data modules
4008// Support: IE <=9 - 11, Edge 12 - 15
4009// Microsoft forgot to hump their vendor prefix (#9572)
4010function camelCase( string ) {4011return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );4012}
4013var acceptData = function( owner ) {4014
4015// Accepts only:4016// - Node4017// - Node.ELEMENT_NODE4018// - Node.DOCUMENT_NODE4019// - Object4020// - Any4021return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );4022};4023
4024
4025
4026
4027function Data() {4028this.expando = jQuery.expando + Data.uid++;4029}
4030
4031Data.uid = 1;4032
4033Data.prototype = {4034
4035cache: function( owner ) {4036
4037// Check if the owner object already has a cache4038var value = owner[ this.expando ];4039
4040// If not, create one4041if ( !value ) {4042value = {};4043
4044// We can accept data for non-element nodes in modern browsers,4045// but we should not, see #8335.4046// Always return an empty object.4047if ( acceptData( owner ) ) {4048
4049// If it is a node unlikely to be stringify-ed or looped over4050// use plain assignment4051if ( owner.nodeType ) {4052owner[ this.expando ] = value;4053
4054// Otherwise secure it in a non-enumerable property4055// configurable must be true to allow the property to be4056// deleted when data is removed4057} else {4058Object.defineProperty( owner, this.expando, {4059value: value,4060configurable: true4061} );4062}4063}4064}4065
4066return value;4067},4068set: function( owner, data, value ) {4069var prop,4070cache = this.cache( owner );4071
4072// Handle: [ owner, key, value ] args4073// Always use camelCase key (gh-2257)4074if ( typeof data === "string" ) {4075cache[ camelCase( data ) ] = value;4076
4077// Handle: [ owner, { properties } ] args4078} else {4079
4080// Copy the properties one-by-one to the cache object4081for ( prop in data ) {4082cache[ camelCase( prop ) ] = data[ prop ];4083}4084}4085return cache;4086},4087get: function( owner, key ) {4088return key === undefined ?4089this.cache( owner ) :4090
4091// Always use camelCase key (gh-2257)4092owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];4093},4094access: function( owner, key, value ) {4095
4096// In cases where either:4097//4098// 1. No key was specified4099// 2. A string key was specified, but no value provided4100//4101// Take the "read" path and allow the get method to determine4102// which value to return, respectively either:4103//4104// 1. The entire cache object4105// 2. The data stored at the key4106//4107if ( key === undefined ||4108( ( key && typeof key === "string" ) && value === undefined ) ) {4109
4110return this.get( owner, key );4111}4112
4113// When the key is not a string, or both a key and value4114// are specified, set or extend (existing objects) with either:4115//4116// 1. An object of properties4117// 2. A key and value4118//4119this.set( owner, key, value );4120
4121// Since the "set" path can have two possible entry points4122// return the expected data based on which path was taken[*]4123return value !== undefined ? value : key;4124},4125remove: function( owner, key ) {4126var i,4127cache = owner[ this.expando ];4128
4129if ( cache === undefined ) {4130return;4131}4132
4133if ( key !== undefined ) {4134
4135// Support array or space separated string of keys4136if ( Array.isArray( key ) ) {4137
4138// If key is an array of keys...4139// We always set camelCase keys, so remove that.4140key = key.map( camelCase );4141} else {4142key = camelCase( key );4143
4144// If a key with the spaces exists, use it.4145// Otherwise, create an array by matching non-whitespace4146key = key in cache ?4147[ key ] :4148( key.match( rnothtmlwhite ) || [] );4149}4150
4151i = key.length;4152
4153while ( i-- ) {4154delete cache[ key[ i ] ];4155}4156}4157
4158// Remove the expando if there's no more data4159if ( key === undefined || jQuery.isEmptyObject( cache ) ) {4160
4161// Support: Chrome <=35 - 454162// Webkit & Blink performance suffers when deleting properties4163// from DOM nodes, so set to undefined instead4164// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)4165if ( owner.nodeType ) {4166owner[ this.expando ] = undefined;4167} else {4168delete owner[ this.expando ];4169}4170}4171},4172hasData: function( owner ) {4173var cache = owner[ this.expando ];4174return cache !== undefined && !jQuery.isEmptyObject( cache );4175}4176};4177var dataPriv = new Data();4178
4179var dataUser = new Data();4180
4181
4182
4183// Implementation Summary
4184//
4185// 1. Enforce API surface and semantic compatibility with 1.9.x branch
4186// 2. Improve the module's maintainability by reducing the storage
4187// paths to a single mechanism.
4188// 3. Use the same single mechanism to support "private" and "user" data.
4189// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4190// 5. Avoid exposing implementation details on user objects (eg. expando properties)
4191// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
4192
4193var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,4194rmultiDash = /[A-Z]/g;4195
4196function getData( data ) {4197if ( data === "true" ) {4198return true;4199}4200
4201if ( data === "false" ) {4202return false;4203}4204
4205if ( data === "null" ) {4206return null;4207}4208
4209// Only convert to a number if it doesn't change the string4210if ( data === +data + "" ) {4211return +data;4212}4213
4214if ( rbrace.test( data ) ) {4215return JSON.parse( data );4216}4217
4218return data;4219}
4220
4221function dataAttr( elem, key, data ) {4222var name;4223
4224// If nothing was found internally, try to fetch any4225// data from the HTML5 data-* attribute4226if ( data === undefined && elem.nodeType === 1 ) {4227name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();4228data = elem.getAttribute( name );4229
4230if ( typeof data === "string" ) {4231try {4232data = getData( data );4233} catch ( e ) {}4234
4235// Make sure we set the data so it isn't changed later4236dataUser.set( elem, key, data );4237} else {4238data = undefined;4239}4240}4241return data;4242}
4243
4244jQuery.extend( {4245hasData: function( elem ) {4246return dataUser.hasData( elem ) || dataPriv.hasData( elem );4247},4248
4249data: function( elem, name, data ) {4250return dataUser.access( elem, name, data );4251},4252
4253removeData: function( elem, name ) {4254dataUser.remove( elem, name );4255},4256
4257// TODO: Now that all calls to _data and _removeData have been replaced4258// with direct calls to dataPriv methods, these can be deprecated.4259_data: function( elem, name, data ) {4260return dataPriv.access( elem, name, data );4261},4262
4263_removeData: function( elem, name ) {4264dataPriv.remove( elem, name );4265}4266} );4267
4268jQuery.fn.extend( {4269data: function( key, value ) {4270var i, name, data,4271elem = this[ 0 ],4272attrs = elem && elem.attributes;4273
4274// Gets all values4275if ( key === undefined ) {4276if ( this.length ) {4277data = dataUser.get( elem );4278
4279if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {4280i = attrs.length;4281while ( i-- ) {4282
4283// Support: IE 11 only4284// The attrs elements can be null (#14894)4285if ( attrs[ i ] ) {4286name = attrs[ i ].name;4287if ( name.indexOf( "data-" ) === 0 ) {4288name = camelCase( name.slice( 5 ) );4289dataAttr( elem, name, data[ name ] );4290}4291}4292}4293dataPriv.set( elem, "hasDataAttrs", true );4294}4295}4296
4297return data;4298}4299
4300// Sets multiple values4301if ( typeof key === "object" ) {4302return this.each( function() {4303dataUser.set( this, key );4304} );4305}4306
4307return access( this, function( value ) {4308var data;4309
4310// The calling jQuery object (element matches) is not empty4311// (and therefore has an element appears at this[ 0 ]) and the4312// `value` parameter was not undefined. An empty jQuery object4313// will result in `undefined` for elem = this[ 0 ] which will4314// throw an exception if an attempt to read a data cache is made.4315if ( elem && value === undefined ) {4316
4317// Attempt to get data from the cache4318// The key will always be camelCased in Data4319data = dataUser.get( elem, key );4320if ( data !== undefined ) {4321return data;4322}4323
4324// Attempt to "discover" the data in4325// HTML5 custom data-* attrs4326data = dataAttr( elem, key );4327if ( data !== undefined ) {4328return data;4329}4330
4331// We tried really hard, but the data doesn't exist.4332return;4333}4334
4335// Set the data...4336this.each( function() {4337
4338// We always store the camelCased key4339dataUser.set( this, key, value );4340} );4341}, null, value, arguments.length > 1, null, true );4342},4343
4344removeData: function( key ) {4345return this.each( function() {4346dataUser.remove( this, key );4347} );4348}4349} );4350
4351
4352jQuery.extend( {4353queue: function( elem, type, data ) {4354var queue;4355
4356if ( elem ) {4357type = ( type || "fx" ) + "queue";4358queue = dataPriv.get( elem, type );4359
4360// Speed up dequeue by getting out quickly if this is just a lookup4361if ( data ) {4362if ( !queue || Array.isArray( data ) ) {4363queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );4364} else {4365queue.push( data );4366}4367}4368return queue || [];4369}4370},4371
4372dequeue: function( elem, type ) {4373type = type || "fx";4374
4375var queue = jQuery.queue( elem, type ),4376startLength = queue.length,4377fn = queue.shift(),4378hooks = jQuery._queueHooks( elem, type ),4379next = function() {4380jQuery.dequeue( elem, type );4381};4382
4383// If the fx queue is dequeued, always remove the progress sentinel4384if ( fn === "inprogress" ) {4385fn = queue.shift();4386startLength--;4387}4388
4389if ( fn ) {4390
4391// Add a progress sentinel to prevent the fx queue from being4392// automatically dequeued4393if ( type === "fx" ) {4394queue.unshift( "inprogress" );4395}4396
4397// Clear up the last queue stop function4398delete hooks.stop;4399fn.call( elem, next, hooks );4400}4401
4402if ( !startLength && hooks ) {4403hooks.empty.fire();4404}4405},4406
4407// Not public - generate a queueHooks object, or return the current one4408_queueHooks: function( elem, type ) {4409var key = type + "queueHooks";4410return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {4411empty: jQuery.Callbacks( "once memory" ).add( function() {4412dataPriv.remove( elem, [ type + "queue", key ] );4413} )4414} );4415}4416} );4417
4418jQuery.fn.extend( {4419queue: function( type, data ) {4420var setter = 2;4421
4422if ( typeof type !== "string" ) {4423data = type;4424type = "fx";4425setter--;4426}4427
4428if ( arguments.length < setter ) {4429return jQuery.queue( this[ 0 ], type );4430}4431
4432return data === undefined ?4433this :4434this.each( function() {4435var queue = jQuery.queue( this, type, data );4436
4437// Ensure a hooks for this queue4438jQuery._queueHooks( this, type );4439
4440if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {4441jQuery.dequeue( this, type );4442}4443} );4444},4445dequeue: function( type ) {4446return this.each( function() {4447jQuery.dequeue( this, type );4448} );4449},4450clearQueue: function( type ) {4451return this.queue( type || "fx", [] );4452},4453
4454// Get a promise resolved when queues of a certain type4455// are emptied (fx is the type by default)4456promise: function( type, obj ) {4457var tmp,4458count = 1,4459defer = jQuery.Deferred(),4460elements = this,4461i = this.length,4462resolve = function() {4463if ( !( --count ) ) {4464defer.resolveWith( elements, [ elements ] );4465}4466};4467
4468if ( typeof type !== "string" ) {4469obj = type;4470type = undefined;4471}4472type = type || "fx";4473
4474while ( i-- ) {4475tmp = dataPriv.get( elements[ i ], type + "queueHooks" );4476if ( tmp && tmp.empty ) {4477count++;4478tmp.empty.add( resolve );4479}4480}4481resolve();4482return defer.promise( obj );4483}4484} );4485var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;4486
4487var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );4488
4489
4490var cssExpand = [ "Top", "Right", "Bottom", "Left" ];4491
4492var documentElement = document.documentElement;4493
4494
4495
4496var isAttached = function( elem ) {4497return jQuery.contains( elem.ownerDocument, elem );4498},4499composed = { composed: true };4500
4501// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only4502// Check attachment across shadow DOM boundaries when possible (gh-3504)4503// Support: iOS 10.0-10.2 only4504// Early iOS 10 versions support `attachShadow` but not `getRootNode`,4505// leading to errors. We need to check for `getRootNode`.4506if ( documentElement.getRootNode ) {4507isAttached = function( elem ) {4508return jQuery.contains( elem.ownerDocument, elem ) ||4509elem.getRootNode( composed ) === elem.ownerDocument;4510};4511}4512var isHiddenWithinTree = function( elem, el ) {4513
4514// isHiddenWithinTree might be called from jQuery#filter function;4515// in that case, element will be second argument4516elem = el || elem;4517
4518// Inline style trumps all4519return elem.style.display === "none" ||4520elem.style.display === "" &&4521
4522// Otherwise, check computed style4523// Support: Firefox <=43 - 454524// Disconnected elements can have computed display: none, so first confirm that elem is4525// in the document.4526isAttached( elem ) &&4527
4528jQuery.css( elem, "display" ) === "none";4529};4530
4531var swap = function( elem, options, callback, args ) {4532var ret, name,4533old = {};4534
4535// Remember the old values, and insert the new ones4536for ( name in options ) {4537old[ name ] = elem.style[ name ];4538elem.style[ name ] = options[ name ];4539}4540
4541ret = callback.apply( elem, args || [] );4542
4543// Revert the old values4544for ( name in options ) {4545elem.style[ name ] = old[ name ];4546}4547
4548return ret;4549};4550
4551
4552
4553
4554function adjustCSS( elem, prop, valueParts, tween ) {4555var adjusted, scale,4556maxIterations = 20,4557currentValue = tween ?4558function() {4559return tween.cur();4560} :4561function() {4562return jQuery.css( elem, prop, "" );4563},4564initial = currentValue(),4565unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),4566
4567// Starting value computation is required for potential unit mismatches4568initialInUnit = elem.nodeType &&4569( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&4570rcssNum.exec( jQuery.css( elem, prop ) );4571
4572if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {4573
4574// Support: Firefox <=544575// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)4576initial = initial / 2;4577
4578// Trust units reported by jQuery.css4579unit = unit || initialInUnit[ 3 ];4580
4581// Iteratively approximate from a nonzero starting point4582initialInUnit = +initial || 1;4583
4584while ( maxIterations-- ) {4585
4586// Evaluate and update our best guess (doubling guesses that zero out).4587// Finish if the scale equals or crosses 1 (making the old*new product non-positive).4588jQuery.style( elem, prop, initialInUnit + unit );4589if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {4590maxIterations = 0;4591}4592initialInUnit = initialInUnit / scale;4593
4594}4595
4596initialInUnit = initialInUnit * 2;4597jQuery.style( elem, prop, initialInUnit + unit );4598
4599// Make sure we update the tween properties later on4600valueParts = valueParts || [];4601}4602
4603if ( valueParts ) {4604initialInUnit = +initialInUnit || +initial || 0;4605
4606// Apply relative offset (+=/-=) if specified4607adjusted = valueParts[ 1 ] ?4608initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :4609+valueParts[ 2 ];4610if ( tween ) {4611tween.unit = unit;4612tween.start = initialInUnit;4613tween.end = adjusted;4614}4615}4616return adjusted;4617}
4618
4619
4620var defaultDisplayMap = {};4621
4622function getDefaultDisplay( elem ) {4623var temp,4624doc = elem.ownerDocument,4625nodeName = elem.nodeName,4626display = defaultDisplayMap[ nodeName ];4627
4628if ( display ) {4629return display;4630}4631
4632temp = doc.body.appendChild( doc.createElement( nodeName ) );4633display = jQuery.css( temp, "display" );4634
4635temp.parentNode.removeChild( temp );4636
4637if ( display === "none" ) {4638display = "block";4639}4640defaultDisplayMap[ nodeName ] = display;4641
4642return display;4643}
4644
4645function showHide( elements, show ) {4646var display, elem,4647values = [],4648index = 0,4649length = elements.length;4650
4651// Determine new display value for elements that need to change4652for ( ; index < length; index++ ) {4653elem = elements[ index ];4654if ( !elem.style ) {4655continue;4656}4657
4658display = elem.style.display;4659if ( show ) {4660
4661// Since we force visibility upon cascade-hidden elements, an immediate (and slow)4662// check is required in this first loop unless we have a nonempty display value (either4663// inline or about-to-be-restored)4664if ( display === "none" ) {4665values[ index ] = dataPriv.get( elem, "display" ) || null;4666if ( !values[ index ] ) {4667elem.style.display = "";4668}4669}4670if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {4671values[ index ] = getDefaultDisplay( elem );4672}4673} else {4674if ( display !== "none" ) {4675values[ index ] = "none";4676
4677// Remember what we're overwriting4678dataPriv.set( elem, "display", display );4679}4680}4681}4682
4683// Set the display of the elements in a second loop to avoid constant reflow4684for ( index = 0; index < length; index++ ) {4685if ( values[ index ] != null ) {4686elements[ index ].style.display = values[ index ];4687}4688}4689
4690return elements;4691}
4692
4693jQuery.fn.extend( {4694show: function() {4695return showHide( this, true );4696},4697hide: function() {4698return showHide( this );4699},4700toggle: function( state ) {4701if ( typeof state === "boolean" ) {4702return state ? this.show() : this.hide();4703}4704
4705return this.each( function() {4706if ( isHiddenWithinTree( this ) ) {4707jQuery( this ).show();4708} else {4709jQuery( this ).hide();4710}4711} );4712}4713} );4714var rcheckableType = ( /^(?:checkbox|radio)$/i );4715
4716var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );4717
4718var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );4719
4720
4721
4722// We have to close these tags to support XHTML (#13200)
4723var wrapMap = {4724
4725// Support: IE <=9 only4726option: [ 1, "<select multiple='multiple'>", "</select>" ],4727
4728// XHTML parsers do not magically insert elements in the4729// same way that tag soup parsers do. So we cannot shorten4730// this by omitting <tbody> or other required elements.4731thead: [ 1, "<table>", "</table>" ],4732col: [ 2, "<table><colgroup>", "</colgroup></table>" ],4733tr: [ 2, "<table><tbody>", "</tbody></table>" ],4734td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],4735
4736_default: [ 0, "", "" ]4737};4738
4739// Support: IE <=9 only
4740wrapMap.optgroup = wrapMap.option;4741
4742wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;4743wrapMap.th = wrapMap.td;4744
4745
4746function getAll( context, tag ) {4747
4748// Support: IE <=9 - 11 only4749// Use typeof to avoid zero-argument method invocation on host objects (#15151)4750var ret;4751
4752if ( typeof context.getElementsByTagName !== "undefined" ) {4753ret = context.getElementsByTagName( tag || "*" );4754
4755} else if ( typeof context.querySelectorAll !== "undefined" ) {4756ret = context.querySelectorAll( tag || "*" );4757
4758} else {4759ret = [];4760}4761
4762if ( tag === undefined || tag && nodeName( context, tag ) ) {4763return jQuery.merge( [ context ], ret );4764}4765
4766return ret;4767}
4768
4769
4770// Mark scripts as having already been evaluated
4771function setGlobalEval( elems, refElements ) {4772var i = 0,4773l = elems.length;4774
4775for ( ; i < l; i++ ) {4776dataPriv.set(4777elems[ i ],4778"globalEval",4779!refElements || dataPriv.get( refElements[ i ], "globalEval" )4780);4781}4782}
4783
4784
4785var rhtml = /<|&#?\w+;/;4786
4787function buildFragment( elems, context, scripts, selection, ignored ) {4788var elem, tmp, tag, wrap, attached, j,4789fragment = context.createDocumentFragment(),4790nodes = [],4791i = 0,4792l = elems.length;4793
4794for ( ; i < l; i++ ) {4795elem = elems[ i ];4796
4797if ( elem || elem === 0 ) {4798
4799// Add nodes directly4800if ( toType( elem ) === "object" ) {4801
4802// Support: Android <=4.0 only, PhantomJS 1 only4803// push.apply(_, arraylike) throws on ancient WebKit4804jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );4805
4806// Convert non-html into a text node4807} else if ( !rhtml.test( elem ) ) {4808nodes.push( context.createTextNode( elem ) );4809
4810// Convert html into DOM nodes4811} else {4812tmp = tmp || fragment.appendChild( context.createElement( "div" ) );4813
4814// Deserialize a standard representation4815tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();4816wrap = wrapMap[ tag ] || wrapMap._default;4817tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];4818
4819// Descend through wrappers to the right content4820j = wrap[ 0 ];4821while ( j-- ) {4822tmp = tmp.lastChild;4823}4824
4825// Support: Android <=4.0 only, PhantomJS 1 only4826// push.apply(_, arraylike) throws on ancient WebKit4827jQuery.merge( nodes, tmp.childNodes );4828
4829// Remember the top-level container4830tmp = fragment.firstChild;4831
4832// Ensure the created nodes are orphaned (#12392)4833tmp.textContent = "";4834}4835}4836}4837
4838// Remove wrapper from fragment4839fragment.textContent = "";4840
4841i = 0;4842while ( ( elem = nodes[ i++ ] ) ) {4843
4844// Skip elements already in the context collection (trac-4087)4845if ( selection && jQuery.inArray( elem, selection ) > -1 ) {4846if ( ignored ) {4847ignored.push( elem );4848}4849continue;4850}4851
4852attached = isAttached( elem );4853
4854// Append to fragment4855tmp = getAll( fragment.appendChild( elem ), "script" );4856
4857// Preserve script evaluation history4858if ( attached ) {4859setGlobalEval( tmp );4860}4861
4862// Capture executables4863if ( scripts ) {4864j = 0;4865while ( ( elem = tmp[ j++ ] ) ) {4866if ( rscriptType.test( elem.type || "" ) ) {4867scripts.push( elem );4868}4869}4870}4871}4872
4873return fragment;4874}
4875
4876
4877( function() {4878var fragment = document.createDocumentFragment(),4879div = fragment.appendChild( document.createElement( "div" ) ),4880input = document.createElement( "input" );4881
4882// Support: Android 4.0 - 4.3 only4883// Check state lost if the name is set (#11217)4884// Support: Windows Web Apps (WWA)4885// `name` and `type` must use .setAttribute for WWA (#14901)4886input.setAttribute( "type", "radio" );4887input.setAttribute( "checked", "checked" );4888input.setAttribute( "name", "t" );4889
4890div.appendChild( input );4891
4892// Support: Android <=4.1 only4893// Older WebKit doesn't clone checked state correctly in fragments4894support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;4895
4896// Support: IE <=11 only4897// Make sure textarea (and checkbox) defaultValue is properly cloned4898div.innerHTML = "<textarea>x</textarea>";4899support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;4900} )();4901
4902
4903var
4904rkeyEvent = /^key/,4905rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,4906rtypenamespace = /^([^.]*)(?:\.(.+)|)/;4907
4908function returnTrue() {4909return true;4910}
4911
4912function returnFalse() {4913return false;4914}
4915
4916// Support: IE <=9 - 11+
4917// focus() and blur() are asynchronous, except when they are no-op.
4918// So expect focus to be synchronous when the element is already active,
4919// and blur to be synchronous when the element is not already active.
4920// (focus and blur are always synchronous in other supported browsers,
4921// this just defines when we can count on it).
4922function expectSync( elem, type ) {4923return ( elem === safeActiveElement() ) === ( type === "focus" );4924}
4925
4926// Support: IE <=9 only
4927// Accessing document.activeElement can throw unexpectedly
4928// https://bugs.jquery.com/ticket/13393
4929function safeActiveElement() {4930try {4931return document.activeElement;4932} catch ( err ) { }4933}
4934
4935function on( elem, types, selector, data, fn, one ) {4936var origFn, type;4937
4938// Types can be a map of types/handlers4939if ( typeof types === "object" ) {4940
4941// ( types-Object, selector, data )4942if ( typeof selector !== "string" ) {4943
4944// ( types-Object, data )4945data = data || selector;4946selector = undefined;4947}4948for ( type in types ) {4949on( elem, type, selector, data, types[ type ], one );4950}4951return elem;4952}4953
4954if ( data == null && fn == null ) {4955
4956// ( types, fn )4957fn = selector;4958data = selector = undefined;4959} else if ( fn == null ) {4960if ( typeof selector === "string" ) {4961
4962// ( types, selector, fn )4963fn = data;4964data = undefined;4965} else {4966
4967// ( types, data, fn )4968fn = data;4969data = selector;4970selector = undefined;4971}4972}4973if ( fn === false ) {4974fn = returnFalse;4975} else if ( !fn ) {4976return elem;4977}4978
4979if ( one === 1 ) {4980origFn = fn;4981fn = function( event ) {4982
4983// Can use an empty set, since event contains the info4984jQuery().off( event );4985return origFn.apply( this, arguments );4986};4987
4988// Use same guid so caller can remove using origFn4989fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );4990}4991return elem.each( function() {4992jQuery.event.add( this, types, fn, data, selector );4993} );4994}
4995
4996/*
4997* Helper functions for managing events -- not part of the public interface.
4998* Props to Dean Edwards' addEvent library for many of the ideas.
4999*/
5000jQuery.event = {5001
5002global: {},5003
5004add: function( elem, types, handler, data, selector ) {5005
5006var handleObjIn, eventHandle, tmp,5007events, t, handleObj,5008special, handlers, type, namespaces, origType,5009elemData = dataPriv.get( elem );5010
5011// Don't attach events to noData or text/comment nodes (but allow plain objects)5012if ( !elemData ) {5013return;5014}5015
5016// Caller can pass in an object of custom data in lieu of the handler5017if ( handler.handler ) {5018handleObjIn = handler;5019handler = handleObjIn.handler;5020selector = handleObjIn.selector;5021}5022
5023// Ensure that invalid selectors throw exceptions at attach time5024// Evaluate against documentElement in case elem is a non-element node (e.g., document)5025if ( selector ) {5026jQuery.find.matchesSelector( documentElement, selector );5027}5028
5029// Make sure that the handler has a unique ID, used to find/remove it later5030if ( !handler.guid ) {5031handler.guid = jQuery.guid++;5032}5033
5034// Init the element's event structure and main handler, if this is the first5035if ( !( events = elemData.events ) ) {5036events = elemData.events = {};5037}5038if ( !( eventHandle = elemData.handle ) ) {5039eventHandle = elemData.handle = function( e ) {5040
5041// Discard the second event of a jQuery.event.trigger() and5042// when an event is called after a page has unloaded5043return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?5044jQuery.event.dispatch.apply( elem, arguments ) : undefined;5045};5046}5047
5048// Handle multiple events separated by a space5049types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];5050t = types.length;5051while ( t-- ) {5052tmp = rtypenamespace.exec( types[ t ] ) || [];5053type = origType = tmp[ 1 ];5054namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();5055
5056// There *must* be a type, no attaching namespace-only handlers5057if ( !type ) {5058continue;5059}5060
5061// If event changes its type, use the special event handlers for the changed type5062special = jQuery.event.special[ type ] || {};5063
5064// If selector defined, determine special event api type, otherwise given type5065type = ( selector ? special.delegateType : special.bindType ) || type;5066
5067// Update special based on newly reset type5068special = jQuery.event.special[ type ] || {};5069
5070// handleObj is passed to all event handlers5071handleObj = jQuery.extend( {5072type: type,5073origType: origType,5074data: data,5075handler: handler,5076guid: handler.guid,5077selector: selector,5078needsContext: selector && jQuery.expr.match.needsContext.test( selector ),5079namespace: namespaces.join( "." )5080}, handleObjIn );5081
5082// Init the event handler queue if we're the first5083if ( !( handlers = events[ type ] ) ) {5084handlers = events[ type ] = [];5085handlers.delegateCount = 0;5086
5087// Only use addEventListener if the special events handler returns false5088if ( !special.setup ||5089special.setup.call( elem, data, namespaces, eventHandle ) === false ) {5090
5091if ( elem.addEventListener ) {5092elem.addEventListener( type, eventHandle );5093}5094}5095}5096
5097if ( special.add ) {5098special.add.call( elem, handleObj );5099
5100if ( !handleObj.handler.guid ) {5101handleObj.handler.guid = handler.guid;5102}5103}5104
5105// Add to the element's handler list, delegates in front5106if ( selector ) {5107handlers.splice( handlers.delegateCount++, 0, handleObj );5108} else {5109handlers.push( handleObj );5110}5111
5112// Keep track of which events have ever been used, for event optimization5113jQuery.event.global[ type ] = true;5114}5115
5116},5117
5118// Detach an event or set of events from an element5119remove: function( elem, types, handler, selector, mappedTypes ) {5120
5121var j, origCount, tmp,5122events, t, handleObj,5123special, handlers, type, namespaces, origType,5124elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );5125
5126if ( !elemData || !( events = elemData.events ) ) {5127return;5128}5129
5130// Once for each type.namespace in types; type may be omitted5131types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];5132t = types.length;5133while ( t-- ) {5134tmp = rtypenamespace.exec( types[ t ] ) || [];5135type = origType = tmp[ 1 ];5136namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();5137
5138// Unbind all events (on this namespace, if provided) for the element5139if ( !type ) {5140for ( type in events ) {5141jQuery.event.remove( elem, type + types[ t ], handler, selector, true );5142}5143continue;5144}5145
5146special = jQuery.event.special[ type ] || {};5147type = ( selector ? special.delegateType : special.bindType ) || type;5148handlers = events[ type ] || [];5149tmp = tmp[ 2 ] &&5150new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );5151
5152// Remove matching events5153origCount = j = handlers.length;5154while ( j-- ) {5155handleObj = handlers[ j ];5156
5157if ( ( mappedTypes || origType === handleObj.origType ) &&5158( !handler || handler.guid === handleObj.guid ) &&5159( !tmp || tmp.test( handleObj.namespace ) ) &&5160( !selector || selector === handleObj.selector ||5161selector === "**" && handleObj.selector ) ) {5162handlers.splice( j, 1 );5163
5164if ( handleObj.selector ) {5165handlers.delegateCount--;5166}5167if ( special.remove ) {5168special.remove.call( elem, handleObj );5169}5170}5171}5172
5173// Remove generic event handler if we removed something and no more handlers exist5174// (avoids potential for endless recursion during removal of special event handlers)5175if ( origCount && !handlers.length ) {5176if ( !special.teardown ||5177special.teardown.call( elem, namespaces, elemData.handle ) === false ) {5178
5179jQuery.removeEvent( elem, type, elemData.handle );5180}5181
5182delete events[ type ];5183}5184}5185
5186// Remove data and the expando if it's no longer used5187if ( jQuery.isEmptyObject( events ) ) {5188dataPriv.remove( elem, "handle events" );5189}5190},5191
5192dispatch: function( nativeEvent ) {5193
5194// Make a writable jQuery.Event from the native event object5195var event = jQuery.event.fix( nativeEvent );5196
5197var i, j, ret, matched, handleObj, handlerQueue,5198args = new Array( arguments.length ),5199handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],5200special = jQuery.event.special[ event.type ] || {};5201
5202// Use the fix-ed jQuery.Event rather than the (read-only) native event5203args[ 0 ] = event;5204
5205for ( i = 1; i < arguments.length; i++ ) {5206args[ i ] = arguments[ i ];5207}5208
5209event.delegateTarget = this;5210
5211// Call the preDispatch hook for the mapped type, and let it bail if desired5212if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {5213return;5214}5215
5216// Determine handlers5217handlerQueue = jQuery.event.handlers.call( this, event, handlers );5218
5219// Run delegates first; they may want to stop propagation beneath us5220i = 0;5221while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {5222event.currentTarget = matched.elem;5223
5224j = 0;5225while ( ( handleObj = matched.handlers[ j++ ] ) &&5226!event.isImmediatePropagationStopped() ) {5227
5228// If the event is namespaced, then each handler is only invoked if it is5229// specially universal or its namespaces are a superset of the event's.5230if ( !event.rnamespace || handleObj.namespace === false ||5231event.rnamespace.test( handleObj.namespace ) ) {5232
5233event.handleObj = handleObj;5234event.data = handleObj.data;5235
5236ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||5237handleObj.handler ).apply( matched.elem, args );5238
5239if ( ret !== undefined ) {5240if ( ( event.result = ret ) === false ) {5241event.preventDefault();5242event.stopPropagation();5243}5244}5245}5246}5247}5248
5249// Call the postDispatch hook for the mapped type5250if ( special.postDispatch ) {5251special.postDispatch.call( this, event );5252}5253
5254return event.result;5255},5256
5257handlers: function( event, handlers ) {5258var i, handleObj, sel, matchedHandlers, matchedSelectors,5259handlerQueue = [],5260delegateCount = handlers.delegateCount,5261cur = event.target;5262
5263// Find delegate handlers5264if ( delegateCount &&5265
5266// Support: IE <=95267// Black-hole SVG <use> instance trees (trac-13180)5268cur.nodeType &&5269
5270// Support: Firefox <=425271// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)5272// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click5273// Support: IE 11 only5274// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)5275!( event.type === "click" && event.button >= 1 ) ) {5276
5277for ( ; cur !== this; cur = cur.parentNode || this ) {5278
5279// Don't check non-elements (#13208)5280// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)5281if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {5282matchedHandlers = [];5283matchedSelectors = {};5284for ( i = 0; i < delegateCount; i++ ) {5285handleObj = handlers[ i ];5286
5287// Don't conflict with Object.prototype properties (#13203)5288sel = handleObj.selector + " ";5289
5290if ( matchedSelectors[ sel ] === undefined ) {5291matchedSelectors[ sel ] = handleObj.needsContext ?5292jQuery( sel, this ).index( cur ) > -1 :5293jQuery.find( sel, this, null, [ cur ] ).length;5294}5295if ( matchedSelectors[ sel ] ) {5296matchedHandlers.push( handleObj );5297}5298}5299if ( matchedHandlers.length ) {5300handlerQueue.push( { elem: cur, handlers: matchedHandlers } );5301}5302}5303}5304}5305
5306// Add the remaining (directly-bound) handlers5307cur = this;5308if ( delegateCount < handlers.length ) {5309handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );5310}5311
5312return handlerQueue;5313},5314
5315addProp: function( name, hook ) {5316Object.defineProperty( jQuery.Event.prototype, name, {5317enumerable: true,5318configurable: true,5319
5320get: isFunction( hook ) ?5321function() {5322if ( this.originalEvent ) {5323return hook( this.originalEvent );5324}5325} :5326function() {5327if ( this.originalEvent ) {5328return this.originalEvent[ name ];5329}5330},5331
5332set: function( value ) {5333Object.defineProperty( this, name, {5334enumerable: true,5335configurable: true,5336writable: true,5337value: value5338} );5339}5340} );5341},5342
5343fix: function( originalEvent ) {5344return originalEvent[ jQuery.expando ] ?5345originalEvent :5346new jQuery.Event( originalEvent );5347},5348
5349special: {5350load: {5351
5352// Prevent triggered image.load events from bubbling to window.load5353noBubble: true5354},5355click: {5356
5357// Utilize native event to ensure correct state for checkable inputs5358setup: function( data ) {5359
5360// For mutual compressibility with _default, replace `this` access with a local var.5361// `|| data` is dead code meant only to preserve the variable through minification.5362var el = this || data;5363
5364// Claim the first handler5365if ( rcheckableType.test( el.type ) &&5366el.click && nodeName( el, "input" ) ) {5367
5368// dataPriv.set( el, "click", ... )5369leverageNative( el, "click", returnTrue );5370}5371
5372// Return false to allow normal processing in the caller5373return false;5374},5375trigger: function( data ) {5376
5377// For mutual compressibility with _default, replace `this` access with a local var.5378// `|| data` is dead code meant only to preserve the variable through minification.5379var el = this || data;5380
5381// Force setup before triggering a click5382if ( rcheckableType.test( el.type ) &&5383el.click && nodeName( el, "input" ) ) {5384
5385leverageNative( el, "click" );5386}5387
5388// Return non-false to allow normal event-path propagation5389return true;5390},5391
5392// For cross-browser consistency, suppress native .click() on links5393// Also prevent it if we're currently inside a leveraged native-event stack5394_default: function( event ) {5395var target = event.target;5396return rcheckableType.test( target.type ) &&5397target.click && nodeName( target, "input" ) &&5398dataPriv.get( target, "click" ) ||5399nodeName( target, "a" );5400}5401},5402
5403beforeunload: {5404postDispatch: function( event ) {5405
5406// Support: Firefox 20+5407// Firefox doesn't alert if the returnValue field is not set.5408if ( event.result !== undefined && event.originalEvent ) {5409event.originalEvent.returnValue = event.result;5410}5411}5412}5413}5414};5415
5416// Ensure the presence of an event listener that handles manually-triggered
5417// synthetic events by interrupting progress until reinvoked in response to
5418// *native* events that it fires directly, ensuring that state changes have
5419// already occurred before other listeners are invoked.
5420function leverageNative( el, type, expectSync ) {5421
5422// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add5423if ( !expectSync ) {5424if ( dataPriv.get( el, type ) === undefined ) {5425jQuery.event.add( el, type, returnTrue );5426}5427return;5428}5429
5430// Register the controller as a special universal handler for all event namespaces5431dataPriv.set( el, type, false );5432jQuery.event.add( el, type, {5433namespace: false,5434handler: function( event ) {5435var notAsync, result,5436saved = dataPriv.get( this, type );5437
5438if ( ( event.isTrigger & 1 ) && this[ type ] ) {5439
5440// Interrupt processing of the outer synthetic .trigger()ed event5441// Saved data should be false in such cases, but might be a leftover capture object5442// from an async native handler (gh-4350)5443if ( !saved.length ) {5444
5445// Store arguments for use when handling the inner native event5446// There will always be at least one argument (an event object), so this array5447// will not be confused with a leftover capture object.5448saved = slice.call( arguments );5449dataPriv.set( this, type, saved );5450
5451// Trigger the native event and capture its result5452// Support: IE <=9 - 11+5453// focus() and blur() are asynchronous5454notAsync = expectSync( this, type );5455this[ type ]();5456result = dataPriv.get( this, type );5457if ( saved !== result || notAsync ) {5458dataPriv.set( this, type, false );5459} else {5460result = {};5461}5462if ( saved !== result ) {5463
5464// Cancel the outer synthetic event5465event.stopImmediatePropagation();5466event.preventDefault();5467return result.value;5468}5469
5470// If this is an inner synthetic event for an event with a bubbling surrogate5471// (focus or blur), assume that the surrogate already propagated from triggering the5472// native event and prevent that from happening again here.5473// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the5474// bubbling surrogate propagates *after* the non-bubbling base), but that seems5475// less bad than duplication.5476} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {5477event.stopPropagation();5478}5479
5480// If this is a native event triggered above, everything is now in order5481// Fire an inner synthetic event with the original arguments5482} else if ( saved.length ) {5483
5484// ...and capture the result5485dataPriv.set( this, type, {5486value: jQuery.event.trigger(5487
5488// Support: IE <=9 - 11+5489// Extend with the prototype to reset the above stopImmediatePropagation()5490jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),5491saved.slice( 1 ),5492this5493)5494} );5495
5496// Abort handling of the native event5497event.stopImmediatePropagation();5498}5499}5500} );5501}
5502
5503jQuery.removeEvent = function( elem, type, handle ) {5504
5505// This "if" is needed for plain objects5506if ( elem.removeEventListener ) {5507elem.removeEventListener( type, handle );5508}5509};5510
5511jQuery.Event = function( src, props ) {5512
5513// Allow instantiation without the 'new' keyword5514if ( !( this instanceof jQuery.Event ) ) {5515return new jQuery.Event( src, props );5516}5517
5518// Event object5519if ( src && src.type ) {5520this.originalEvent = src;5521this.type = src.type;5522
5523// Events bubbling up the document may have been marked as prevented5524// by a handler lower down the tree; reflect the correct value.5525this.isDefaultPrevented = src.defaultPrevented ||5526src.defaultPrevented === undefined &&5527
5528// Support: Android <=2.3 only5529src.returnValue === false ?5530returnTrue :5531returnFalse;5532
5533// Create target properties5534// Support: Safari <=6 - 7 only5535// Target should not be a text node (#504, #13143)5536this.target = ( src.target && src.target.nodeType === 3 ) ?5537src.target.parentNode :5538src.target;5539
5540this.currentTarget = src.currentTarget;5541this.relatedTarget = src.relatedTarget;5542
5543// Event type5544} else {5545this.type = src;5546}5547
5548// Put explicitly provided properties onto the event object5549if ( props ) {5550jQuery.extend( this, props );5551}5552
5553// Create a timestamp if incoming event doesn't have one5554this.timeStamp = src && src.timeStamp || Date.now();5555
5556// Mark it as fixed5557this[ jQuery.expando ] = true;5558};5559
5560// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5561// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5562jQuery.Event.prototype = {5563constructor: jQuery.Event,5564isDefaultPrevented: returnFalse,5565isPropagationStopped: returnFalse,5566isImmediatePropagationStopped: returnFalse,5567isSimulated: false,5568
5569preventDefault: function() {5570var e = this.originalEvent;5571
5572this.isDefaultPrevented = returnTrue;5573
5574if ( e && !this.isSimulated ) {5575e.preventDefault();5576}5577},5578stopPropagation: function() {5579var e = this.originalEvent;5580
5581this.isPropagationStopped = returnTrue;5582
5583if ( e && !this.isSimulated ) {5584e.stopPropagation();5585}5586},5587stopImmediatePropagation: function() {5588var e = this.originalEvent;5589
5590this.isImmediatePropagationStopped = returnTrue;5591
5592if ( e && !this.isSimulated ) {5593e.stopImmediatePropagation();5594}5595
5596this.stopPropagation();5597}5598};5599
5600// Includes all common event props including KeyEvent and MouseEvent specific props
5601jQuery.each( {5602altKey: true,5603bubbles: true,5604cancelable: true,5605changedTouches: true,5606ctrlKey: true,5607detail: true,5608eventPhase: true,5609metaKey: true,5610pageX: true,5611pageY: true,5612shiftKey: true,5613view: true,5614"char": true,5615code: true,5616charCode: true,5617key: true,5618keyCode: true,5619button: true,5620buttons: true,5621clientX: true,5622clientY: true,5623offsetX: true,5624offsetY: true,5625pointerId: true,5626pointerType: true,5627screenX: true,5628screenY: true,5629targetTouches: true,5630toElement: true,5631touches: true,5632
5633which: function( event ) {5634var button = event.button;5635
5636// Add which for key events5637if ( event.which == null && rkeyEvent.test( event.type ) ) {5638return event.charCode != null ? event.charCode : event.keyCode;5639}5640
5641// Add which for click: 1 === left; 2 === middle; 3 === right5642if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {5643if ( button & 1 ) {5644return 1;5645}5646
5647if ( button & 2 ) {5648return 3;5649}5650
5651if ( button & 4 ) {5652return 2;5653}5654
5655return 0;5656}5657
5658return event.which;5659}5660}, jQuery.event.addProp );5661
5662jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {5663jQuery.event.special[ type ] = {5664
5665// Utilize native event if possible so blur/focus sequence is correct5666setup: function() {5667
5668// Claim the first handler5669// dataPriv.set( this, "focus", ... )5670// dataPriv.set( this, "blur", ... )5671leverageNative( this, type, expectSync );5672
5673// Return false to allow normal processing in the caller5674return false;5675},5676trigger: function() {5677
5678// Force setup before trigger5679leverageNative( this, type );5680
5681// Return non-false to allow normal event-path propagation5682return true;5683},5684
5685delegateType: delegateType5686};5687} );5688
5689// Create mouseenter/leave events using mouseover/out and event-time checks
5690// so that event delegation works in jQuery.
5691// Do the same for pointerenter/pointerleave and pointerover/pointerout
5692//
5693// Support: Safari 7 only
5694// Safari sends mouseenter too often; see:
5695// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5696// for the description of the bug (it existed in older Chrome versions as well).
5697jQuery.each( {5698mouseenter: "mouseover",5699mouseleave: "mouseout",5700pointerenter: "pointerover",5701pointerleave: "pointerout"5702}, function( orig, fix ) {5703jQuery.event.special[ orig ] = {5704delegateType: fix,5705bindType: fix,5706
5707handle: function( event ) {5708var ret,5709target = this,5710related = event.relatedTarget,5711handleObj = event.handleObj;5712
5713// For mouseenter/leave call the handler if related is outside the target.5714// NB: No relatedTarget if the mouse left/entered the browser window5715if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {5716event.type = handleObj.origType;5717ret = handleObj.handler.apply( this, arguments );5718event.type = fix;5719}5720return ret;5721}5722};5723} );5724
5725jQuery.fn.extend( {5726
5727on: function( types, selector, data, fn ) {5728return on( this, types, selector, data, fn );5729},5730one: function( types, selector, data, fn ) {5731return on( this, types, selector, data, fn, 1 );5732},5733off: function( types, selector, fn ) {5734var handleObj, type;5735if ( types && types.preventDefault && types.handleObj ) {5736
5737// ( event ) dispatched jQuery.Event5738handleObj = types.handleObj;5739jQuery( types.delegateTarget ).off(5740handleObj.namespace ?5741handleObj.origType + "." + handleObj.namespace :5742handleObj.origType,5743handleObj.selector,5744handleObj.handler5745);5746return this;5747}5748if ( typeof types === "object" ) {5749
5750// ( types-object [, selector] )5751for ( type in types ) {5752this.off( type, selector, types[ type ] );5753}5754return this;5755}5756if ( selector === false || typeof selector === "function" ) {5757
5758// ( types [, fn] )5759fn = selector;5760selector = undefined;5761}5762if ( fn === false ) {5763fn = returnFalse;5764}5765return this.each( function() {5766jQuery.event.remove( this, types, fn, selector );5767} );5768}5769} );5770
5771
5772var
5773
5774/* eslint-disable max-len */5775
5776// See https://github.com/eslint/eslint/issues/32295777rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,5778
5779/* eslint-enable */5780
5781// Support: IE <=10 - 11, Edge 12 - 13 only5782// In IE/Edge using regex groups here causes severe slowdowns.5783// See https://connect.microsoft.com/IE/feedback/details/1736512/5784rnoInnerhtml = /<script|<style|<link/i,5785
5786// checked="checked" or checked5787rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,5788rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;5789
5790// Prefer a tbody over its parent table for containing new rows
5791function manipulationTarget( elem, content ) {5792if ( nodeName( elem, "table" ) &&5793nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {5794
5795return jQuery( elem ).children( "tbody" )[ 0 ] || elem;5796}5797
5798return elem;5799}
5800
5801// Replace/restore the type attribute of script elements for safe DOM manipulation
5802function disableScript( elem ) {5803elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;5804return elem;5805}
5806function restoreScript( elem ) {5807if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {5808elem.type = elem.type.slice( 5 );5809} else {5810elem.removeAttribute( "type" );5811}5812
5813return elem;5814}
5815
5816function cloneCopyEvent( src, dest ) {5817var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;5818
5819if ( dest.nodeType !== 1 ) {5820return;5821}5822
5823// 1. Copy private data: events, handlers, etc.5824if ( dataPriv.hasData( src ) ) {5825pdataOld = dataPriv.access( src );5826pdataCur = dataPriv.set( dest, pdataOld );5827events = pdataOld.events;5828
5829if ( events ) {5830delete pdataCur.handle;5831pdataCur.events = {};5832
5833for ( type in events ) {5834for ( i = 0, l = events[ type ].length; i < l; i++ ) {5835jQuery.event.add( dest, type, events[ type ][ i ] );5836}5837}5838}5839}5840
5841// 2. Copy user data5842if ( dataUser.hasData( src ) ) {5843udataOld = dataUser.access( src );5844udataCur = jQuery.extend( {}, udataOld );5845
5846dataUser.set( dest, udataCur );5847}5848}
5849
5850// Fix IE bugs, see support tests
5851function fixInput( src, dest ) {5852var nodeName = dest.nodeName.toLowerCase();5853
5854// Fails to persist the checked state of a cloned checkbox or radio button.5855if ( nodeName === "input" && rcheckableType.test( src.type ) ) {5856dest.checked = src.checked;5857
5858// Fails to return the selected option to the default selected state when cloning options5859} else if ( nodeName === "input" || nodeName === "textarea" ) {5860dest.defaultValue = src.defaultValue;5861}5862}
5863
5864function domManip( collection, args, callback, ignored ) {5865
5866// Flatten any nested arrays5867args = concat.apply( [], args );5868
5869var fragment, first, scripts, hasScripts, node, doc,5870i = 0,5871l = collection.length,5872iNoClone = l - 1,5873value = args[ 0 ],5874valueIsFunction = isFunction( value );5875
5876// We can't cloneNode fragments that contain checked, in WebKit5877if ( valueIsFunction ||5878( l > 1 && typeof value === "string" &&5879!support.checkClone && rchecked.test( value ) ) ) {5880return collection.each( function( index ) {5881var self = collection.eq( index );5882if ( valueIsFunction ) {5883args[ 0 ] = value.call( this, index, self.html() );5884}5885domManip( self, args, callback, ignored );5886} );5887}5888
5889if ( l ) {5890fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );5891first = fragment.firstChild;5892
5893if ( fragment.childNodes.length === 1 ) {5894fragment = first;5895}5896
5897// Require either new content or an interest in ignored elements to invoke the callback5898if ( first || ignored ) {5899scripts = jQuery.map( getAll( fragment, "script" ), disableScript );5900hasScripts = scripts.length;5901
5902// Use the original fragment for the last item5903// instead of the first because it can end up5904// being emptied incorrectly in certain situations (#8070).5905for ( ; i < l; i++ ) {5906node = fragment;5907
5908if ( i !== iNoClone ) {5909node = jQuery.clone( node, true, true );5910
5911// Keep references to cloned scripts for later restoration5912if ( hasScripts ) {5913
5914// Support: Android <=4.0 only, PhantomJS 1 only5915// push.apply(_, arraylike) throws on ancient WebKit5916jQuery.merge( scripts, getAll( node, "script" ) );5917}5918}5919
5920callback.call( collection[ i ], node, i );5921}5922
5923if ( hasScripts ) {5924doc = scripts[ scripts.length - 1 ].ownerDocument;5925
5926// Reenable scripts5927jQuery.map( scripts, restoreScript );5928
5929// Evaluate executable scripts on first document insertion5930for ( i = 0; i < hasScripts; i++ ) {5931node = scripts[ i ];5932if ( rscriptType.test( node.type || "" ) &&5933!dataPriv.access( node, "globalEval" ) &&5934jQuery.contains( doc, node ) ) {5935
5936if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) {5937
5938// Optional AJAX dependency, but won't run scripts if not present5939if ( jQuery._evalUrl && !node.noModule ) {5940jQuery._evalUrl( node.src, {5941nonce: node.nonce || node.getAttribute( "nonce" )5942} );5943}5944} else {5945DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );5946}5947}5948}5949}5950}5951}5952
5953return collection;5954}
5955
5956function remove( elem, selector, keepData ) {5957var node,5958nodes = selector ? jQuery.filter( selector, elem ) : elem,5959i = 0;5960
5961for ( ; ( node = nodes[ i ] ) != null; i++ ) {5962if ( !keepData && node.nodeType === 1 ) {5963jQuery.cleanData( getAll( node ) );5964}5965
5966if ( node.parentNode ) {5967if ( keepData && isAttached( node ) ) {5968setGlobalEval( getAll( node, "script" ) );5969}5970node.parentNode.removeChild( node );5971}5972}5973
5974return elem;5975}
5976
5977jQuery.extend( {5978htmlPrefilter: function( html ) {5979return html.replace( rxhtmlTag, "<$1></$2>" );5980},5981
5982clone: function( elem, dataAndEvents, deepDataAndEvents ) {5983var i, l, srcElements, destElements,5984clone = elem.cloneNode( true ),5985inPage = isAttached( elem );5986
5987// Fix IE cloning issues5988if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&5989!jQuery.isXMLDoc( elem ) ) {5990
5991// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/25992destElements = getAll( clone );5993srcElements = getAll( elem );5994
5995for ( i = 0, l = srcElements.length; i < l; i++ ) {5996fixInput( srcElements[ i ], destElements[ i ] );5997}5998}5999
6000// Copy the events from the original to the clone6001if ( dataAndEvents ) {6002if ( deepDataAndEvents ) {6003srcElements = srcElements || getAll( elem );6004destElements = destElements || getAll( clone );6005
6006for ( i = 0, l = srcElements.length; i < l; i++ ) {6007cloneCopyEvent( srcElements[ i ], destElements[ i ] );6008}6009} else {6010cloneCopyEvent( elem, clone );6011}6012}6013
6014// Preserve script evaluation history6015destElements = getAll( clone, "script" );6016if ( destElements.length > 0 ) {6017setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );6018}6019
6020// Return the cloned set6021return clone;6022},6023
6024cleanData: function( elems ) {6025var data, elem, type,6026special = jQuery.event.special,6027i = 0;6028
6029for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {6030if ( acceptData( elem ) ) {6031if ( ( data = elem[ dataPriv.expando ] ) ) {6032if ( data.events ) {6033for ( type in data.events ) {6034if ( special[ type ] ) {6035jQuery.event.remove( elem, type );6036
6037// This is a shortcut to avoid jQuery.event.remove's overhead6038} else {6039jQuery.removeEvent( elem, type, data.handle );6040}6041}6042}6043
6044// Support: Chrome <=35 - 45+6045// Assign undefined instead of using delete, see Data#remove6046elem[ dataPriv.expando ] = undefined;6047}6048if ( elem[ dataUser.expando ] ) {6049
6050// Support: Chrome <=35 - 45+6051// Assign undefined instead of using delete, see Data#remove6052elem[ dataUser.expando ] = undefined;6053}6054}6055}6056}6057} );6058
6059jQuery.fn.extend( {6060detach: function( selector ) {6061return remove( this, selector, true );6062},6063
6064remove: function( selector ) {6065return remove( this, selector );6066},6067
6068text: function( value ) {6069return access( this, function( value ) {6070return value === undefined ?6071jQuery.text( this ) :6072this.empty().each( function() {6073if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {6074this.textContent = value;6075}6076} );6077}, null, value, arguments.length );6078},6079
6080append: function() {6081return domManip( this, arguments, function( elem ) {6082if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {6083var target = manipulationTarget( this, elem );6084target.appendChild( elem );6085}6086} );6087},6088
6089prepend: function() {6090return domManip( this, arguments, function( elem ) {6091if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {6092var target = manipulationTarget( this, elem );6093target.insertBefore( elem, target.firstChild );6094}6095} );6096},6097
6098before: function() {6099return domManip( this, arguments, function( elem ) {6100if ( this.parentNode ) {6101this.parentNode.insertBefore( elem, this );6102}6103} );6104},6105
6106after: function() {6107return domManip( this, arguments, function( elem ) {6108if ( this.parentNode ) {6109this.parentNode.insertBefore( elem, this.nextSibling );6110}6111} );6112},6113
6114empty: function() {6115var elem,6116i = 0;6117
6118for ( ; ( elem = this[ i ] ) != null; i++ ) {6119if ( elem.nodeType === 1 ) {6120
6121// Prevent memory leaks6122jQuery.cleanData( getAll( elem, false ) );6123
6124// Remove any remaining nodes6125elem.textContent = "";6126}6127}6128
6129return this;6130},6131
6132clone: function( dataAndEvents, deepDataAndEvents ) {6133dataAndEvents = dataAndEvents == null ? false : dataAndEvents;6134deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;6135
6136return this.map( function() {6137return jQuery.clone( this, dataAndEvents, deepDataAndEvents );6138} );6139},6140
6141html: function( value ) {6142return access( this, function( value ) {6143var elem = this[ 0 ] || {},6144i = 0,6145l = this.length;6146
6147if ( value === undefined && elem.nodeType === 1 ) {6148return elem.innerHTML;6149}6150
6151// See if we can take a shortcut and just use innerHTML6152if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&6153!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {6154
6155value = jQuery.htmlPrefilter( value );6156
6157try {6158for ( ; i < l; i++ ) {6159elem = this[ i ] || {};6160
6161// Remove element nodes and prevent memory leaks6162if ( elem.nodeType === 1 ) {6163jQuery.cleanData( getAll( elem, false ) );6164elem.innerHTML = value;6165}6166}6167
6168elem = 0;6169
6170// If using innerHTML throws an exception, use the fallback method6171} catch ( e ) {}6172}6173
6174if ( elem ) {6175this.empty().append( value );6176}6177}, null, value, arguments.length );6178},6179
6180replaceWith: function() {6181var ignored = [];6182
6183// Make the changes, replacing each non-ignored context element with the new content6184return domManip( this, arguments, function( elem ) {6185var parent = this.parentNode;6186
6187if ( jQuery.inArray( this, ignored ) < 0 ) {6188jQuery.cleanData( getAll( this ) );6189if ( parent ) {6190parent.replaceChild( elem, this );6191}6192}6193
6194// Force callback invocation6195}, ignored );6196}6197} );6198
6199jQuery.each( {6200appendTo: "append",6201prependTo: "prepend",6202insertBefore: "before",6203insertAfter: "after",6204replaceAll: "replaceWith"6205}, function( name, original ) {6206jQuery.fn[ name ] = function( selector ) {6207var elems,6208ret = [],6209insert = jQuery( selector ),6210last = insert.length - 1,6211i = 0;6212
6213for ( ; i <= last; i++ ) {6214elems = i === last ? this : this.clone( true );6215jQuery( insert[ i ] )[ original ]( elems );6216
6217// Support: Android <=4.0 only, PhantomJS 1 only6218// .get() because push.apply(_, arraylike) throws on ancient WebKit6219push.apply( ret, elems.get() );6220}6221
6222return this.pushStack( ret );6223};6224} );6225var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );6226
6227var getStyles = function( elem ) {6228
6229// Support: IE <=11 only, Firefox <=30 (#15098, #14150)6230// IE throws on elements created in popups6231// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"6232var view = elem.ownerDocument.defaultView;6233
6234if ( !view || !view.opener ) {6235view = window;6236}6237
6238return view.getComputedStyle( elem );6239};6240
6241var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );6242
6243
6244
6245( function() {6246
6247// Executing both pixelPosition & boxSizingReliable tests require only one layout6248// so they're executed at the same time to save the second computation.6249function computeStyleTests() {6250
6251// This is a singleton, we need to execute it only once6252if ( !div ) {6253return;6254}6255
6256container.style.cssText = "position:absolute;left:-11111px;width:60px;" +6257"margin-top:1px;padding:0;border:0";6258div.style.cssText =6259"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +6260"margin:auto;border:1px;padding:1px;" +6261"width:60%;top:1%";6262documentElement.appendChild( container ).appendChild( div );6263
6264var divStyle = window.getComputedStyle( div );6265pixelPositionVal = divStyle.top !== "1%";6266
6267// Support: Android 4.0 - 4.3 only, Firefox <=3 - 446268reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;6269
6270// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.36271// Some styles come back with percentage values, even though they shouldn't6272div.style.right = "60%";6273pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;6274
6275// Support: IE 9 - 11 only6276// Detect misreporting of content dimensions for box-sizing:border-box elements6277boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;6278
6279// Support: IE 9 only6280// Detect overflow:scroll screwiness (gh-3699)6281// Support: Chrome <=646282// Don't get tricked when zoom affects offsetWidth (gh-4029)6283div.style.position = "absolute";6284scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;6285
6286documentElement.removeChild( container );6287
6288// Nullify the div so it wouldn't be stored in the memory and6289// it will also be a sign that checks already performed6290div = null;6291}6292
6293function roundPixelMeasures( measure ) {6294return Math.round( parseFloat( measure ) );6295}6296
6297var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,6298reliableMarginLeftVal,6299container = document.createElement( "div" ),6300div = document.createElement( "div" );6301
6302// Finish early in limited (non-browser) environments6303if ( !div.style ) {6304return;6305}6306
6307// Support: IE <=9 - 11 only6308// Style of cloned element affects source element cloned (#8908)6309div.style.backgroundClip = "content-box";6310div.cloneNode( true ).style.backgroundClip = "";6311support.clearCloneStyle = div.style.backgroundClip === "content-box";6312
6313jQuery.extend( support, {6314boxSizingReliable: function() {6315computeStyleTests();6316return boxSizingReliableVal;6317},6318pixelBoxStyles: function() {6319computeStyleTests();6320return pixelBoxStylesVal;6321},6322pixelPosition: function() {6323computeStyleTests();6324return pixelPositionVal;6325},6326reliableMarginLeft: function() {6327computeStyleTests();6328return reliableMarginLeftVal;6329},6330scrollboxSize: function() {6331computeStyleTests();6332return scrollboxSizeVal;6333}6334} );6335} )();6336
6337
6338function curCSS( elem, name, computed ) {6339var width, minWidth, maxWidth, ret,6340
6341// Support: Firefox 51+6342// Retrieving style before computed somehow6343// fixes an issue with getting wrong values6344// on detached elements6345style = elem.style;6346
6347computed = computed || getStyles( elem );6348
6349// getPropertyValue is needed for:6350// .css('filter') (IE 9 only, #12537)6351// .css('--customProperty) (#3144)6352if ( computed ) {6353ret = computed.getPropertyValue( name ) || computed[ name ];6354
6355if ( ret === "" && !isAttached( elem ) ) {6356ret = jQuery.style( elem, name );6357}6358
6359// A tribute to the "awesome hack by Dean Edwards"6360// Android Browser returns percentage for some values,6361// but width seems to be reliably pixels.6362// This is against the CSSOM draft spec:6363// https://drafts.csswg.org/cssom/#resolved-values6364if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {6365
6366// Remember the original values6367width = style.width;6368minWidth = style.minWidth;6369maxWidth = style.maxWidth;6370
6371// Put in the new values to get a computed value out6372style.minWidth = style.maxWidth = style.width = ret;6373ret = computed.width;6374
6375// Revert the changed values6376style.width = width;6377style.minWidth = minWidth;6378style.maxWidth = maxWidth;6379}6380}6381
6382return ret !== undefined ?6383
6384// Support: IE <=9 - 11 only6385// IE returns zIndex value as an integer.6386ret + "" :6387ret;6388}
6389
6390
6391function addGetHookIf( conditionFn, hookFn ) {6392
6393// Define the hook, we'll check on the first run if it's really needed.6394return {6395get: function() {6396if ( conditionFn() ) {6397
6398// Hook not needed (or it's not possible to use it due6399// to missing dependency), remove it.6400delete this.get;6401return;6402}6403
6404// Hook needed; redefine it so that the support test is not executed again.6405return ( this.get = hookFn ).apply( this, arguments );6406}6407};6408}
6409
6410
6411var cssPrefixes = [ "Webkit", "Moz", "ms" ],6412emptyStyle = document.createElement( "div" ).style,6413vendorProps = {};6414
6415// Return a vendor-prefixed property or undefined
6416function vendorPropName( name ) {6417
6418// Check for vendor prefixed names6419var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),6420i = cssPrefixes.length;6421
6422while ( i-- ) {6423name = cssPrefixes[ i ] + capName;6424if ( name in emptyStyle ) {6425return name;6426}6427}6428}
6429
6430// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
6431function finalPropName( name ) {6432var final = jQuery.cssProps[ name ] || vendorProps[ name ];6433
6434if ( final ) {6435return final;6436}6437if ( name in emptyStyle ) {6438return name;6439}6440return vendorProps[ name ] = vendorPropName( name ) || name;6441}
6442
6443
6444var
6445
6446// Swappable if display is none or starts with table6447// except "table", "table-cell", or "table-caption"6448// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display6449rdisplayswap = /^(none|table(?!-c[ea]).+)/,6450rcustomProp = /^--/,6451cssShow = { position: "absolute", visibility: "hidden", display: "block" },6452cssNormalTransform = {6453letterSpacing: "0",6454fontWeight: "400"6455};6456
6457function setPositiveNumber( elem, value, subtract ) {6458
6459// Any relative (+/-) values have already been6460// normalized at this point6461var matches = rcssNum.exec( value );6462return matches ?6463
6464// Guard against undefined "subtract", e.g., when used as in cssHooks6465Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :6466value;6467}
6468
6469function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {6470var i = dimension === "width" ? 1 : 0,6471extra = 0,6472delta = 0;6473
6474// Adjustment may not be necessary6475if ( box === ( isBorderBox ? "border" : "content" ) ) {6476return 0;6477}6478
6479for ( ; i < 4; i += 2 ) {6480
6481// Both box models exclude margin6482if ( box === "margin" ) {6483delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );6484}6485
6486// If we get here with a content-box, we're seeking "padding" or "border" or "margin"6487if ( !isBorderBox ) {6488
6489// Add padding6490delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );6491
6492// For "border" or "margin", add border6493if ( box !== "padding" ) {6494delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );6495
6496// But still keep track of it otherwise6497} else {6498extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );6499}6500
6501// If we get here with a border-box (content + padding + border), we're seeking "content" or6502// "padding" or "margin"6503} else {6504
6505// For "content", subtract padding6506if ( box === "content" ) {6507delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );6508}6509
6510// For "content" or "padding", subtract border6511if ( box !== "margin" ) {6512delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );6513}6514}6515}6516
6517// Account for positive content-box scroll gutter when requested by providing computedVal6518if ( !isBorderBox && computedVal >= 0 ) {6519
6520// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border6521// Assuming integer scroll gutter, subtract the rest and round down6522delta += Math.max( 0, Math.ceil(6523elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -6524computedVal -6525delta -6526extra -65270.56528
6529// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter6530// Use an explicit zero to avoid NaN (gh-3964)6531) ) || 0;6532}6533
6534return delta;6535}
6536
6537function getWidthOrHeight( elem, dimension, extra ) {6538
6539// Start with computed style6540var styles = getStyles( elem ),6541
6542// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).6543// Fake content-box until we know it's needed to know the true value.6544boxSizingNeeded = !support.boxSizingReliable() || extra,6545isBorderBox = boxSizingNeeded &&6546jQuery.css( elem, "boxSizing", false, styles ) === "border-box",6547valueIsBorderBox = isBorderBox,6548
6549val = curCSS( elem, dimension, styles ),6550offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );6551
6552// Support: Firefox <=546553// Return a confounding non-pixel value or feign ignorance, as appropriate.6554if ( rnumnonpx.test( val ) ) {6555if ( !extra ) {6556return val;6557}6558val = "auto";6559}6560
6561
6562// Fall back to offsetWidth/offsetHeight when value is "auto"6563// This happens for inline elements with no explicit setting (gh-3571)6564// Support: Android <=4.1 - 4.3 only6565// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)6566// Support: IE 9-11 only6567// Also use offsetWidth/offsetHeight for when box sizing is unreliable6568// We use getClientRects() to check for hidden/disconnected.6569// In those cases, the computed value can be trusted to be border-box6570if ( ( !support.boxSizingReliable() && isBorderBox ||6571val === "auto" ||6572!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&6573elem.getClientRects().length ) {6574
6575isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";6576
6577// Where available, offsetWidth/offsetHeight approximate border box dimensions.6578// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the6579// retrieved value as a content box dimension.6580valueIsBorderBox = offsetProp in elem;6581if ( valueIsBorderBox ) {6582val = elem[ offsetProp ];6583}6584}6585
6586// Normalize "" and auto6587val = parseFloat( val ) || 0;6588
6589// Adjust for the element's box model6590return ( val +6591boxModelAdjustment(6592elem,6593dimension,6594extra || ( isBorderBox ? "border" : "content" ),6595valueIsBorderBox,6596styles,6597
6598// Provide the current computed size to request scroll gutter calculation (gh-3589)6599val
6600)6601) + "px";6602}
6603
6604jQuery.extend( {6605
6606// Add in style property hooks for overriding the default6607// behavior of getting and setting a style property6608cssHooks: {6609opacity: {6610get: function( elem, computed ) {6611if ( computed ) {6612
6613// We should always get a number back from opacity6614var ret = curCSS( elem, "opacity" );6615return ret === "" ? "1" : ret;6616}6617}6618}6619},6620
6621// Don't automatically add "px" to these possibly-unitless properties6622cssNumber: {6623"animationIterationCount": true,6624"columnCount": true,6625"fillOpacity": true,6626"flexGrow": true,6627"flexShrink": true,6628"fontWeight": true,6629"gridArea": true,6630"gridColumn": true,6631"gridColumnEnd": true,6632"gridColumnStart": true,6633"gridRow": true,6634"gridRowEnd": true,6635"gridRowStart": true,6636"lineHeight": true,6637"opacity": true,6638"order": true,6639"orphans": true,6640"widows": true,6641"zIndex": true,6642"zoom": true6643},6644
6645// Add in properties whose names you wish to fix before6646// setting or getting the value6647cssProps: {},6648
6649// Get and set the style property on a DOM Node6650style: function( elem, name, value, extra ) {6651
6652// Don't set styles on text and comment nodes6653if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {6654return;6655}6656
6657// Make sure that we're working with the right name6658var ret, type, hooks,6659origName = camelCase( name ),6660isCustomProp = rcustomProp.test( name ),6661style = elem.style;6662
6663// Make sure that we're working with the right name. We don't6664// want to query the value if it is a CSS custom property6665// since they are user-defined.6666if ( !isCustomProp ) {6667name = finalPropName( origName );6668}6669
6670// Gets hook for the prefixed version, then unprefixed version6671hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];6672
6673// Check if we're setting a value6674if ( value !== undefined ) {6675type = typeof value;6676
6677// Convert "+=" or "-=" to relative numbers (#7345)6678if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {6679value = adjustCSS( elem, name, ret );6680
6681// Fixes bug #92376682type = "number";6683}6684
6685// Make sure that null and NaN values aren't set (#7116)6686if ( value == null || value !== value ) {6687return;6688}6689
6690// If a number was passed in, add the unit (except for certain CSS properties)6691// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append6692// "px" to a few hardcoded values.6693if ( type === "number" && !isCustomProp ) {6694value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );6695}6696
6697// background-* props affect original clone's values6698if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {6699style[ name ] = "inherit";6700}6701
6702// If a hook was provided, use that value, otherwise just set the specified value6703if ( !hooks || !( "set" in hooks ) ||6704( value = hooks.set( elem, value, extra ) ) !== undefined ) {6705
6706if ( isCustomProp ) {6707style.setProperty( name, value );6708} else {6709style[ name ] = value;6710}6711}6712
6713} else {6714
6715// If a hook was provided get the non-computed value from there6716if ( hooks && "get" in hooks &&6717( ret = hooks.get( elem, false, extra ) ) !== undefined ) {6718
6719return ret;6720}6721
6722// Otherwise just get the value from the style object6723return style[ name ];6724}6725},6726
6727css: function( elem, name, extra, styles ) {6728var val, num, hooks,6729origName = camelCase( name ),6730isCustomProp = rcustomProp.test( name );6731
6732// Make sure that we're working with the right name. We don't6733// want to modify the value if it is a CSS custom property6734// since they are user-defined.6735if ( !isCustomProp ) {6736name = finalPropName( origName );6737}6738
6739// Try prefixed name followed by the unprefixed name6740hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];6741
6742// If a hook was provided get the computed value from there6743if ( hooks && "get" in hooks ) {6744val = hooks.get( elem, true, extra );6745}6746
6747// Otherwise, if a way to get the computed value exists, use that6748if ( val === undefined ) {6749val = curCSS( elem, name, styles );6750}6751
6752// Convert "normal" to computed value6753if ( val === "normal" && name in cssNormalTransform ) {6754val = cssNormalTransform[ name ];6755}6756
6757// Make numeric if forced or a qualifier was provided and val looks numeric6758if ( extra === "" || extra ) {6759num = parseFloat( val );6760return extra === true || isFinite( num ) ? num || 0 : val;6761}6762
6763return val;6764}6765} );6766
6767jQuery.each( [ "height", "width" ], function( i, dimension ) {6768jQuery.cssHooks[ dimension ] = {6769get: function( elem, computed, extra ) {6770if ( computed ) {6771
6772// Certain elements can have dimension info if we invisibly show them6773// but it must have a current display style that would benefit6774return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&6775
6776// Support: Safari 8+6777// Table columns in Safari have non-zero offsetWidth & zero6778// getBoundingClientRect().width unless display is changed.6779// Support: IE <=11 only6780// Running getBoundingClientRect on a disconnected node6781// in IE throws an error.6782( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?6783swap( elem, cssShow, function() {6784return getWidthOrHeight( elem, dimension, extra );6785} ) :6786getWidthOrHeight( elem, dimension, extra );6787}6788},6789
6790set: function( elem, value, extra ) {6791var matches,6792styles = getStyles( elem ),6793
6794// Only read styles.position if the test has a chance to fail6795// to avoid forcing a reflow.6796scrollboxSizeBuggy = !support.scrollboxSize() &&6797styles.position === "absolute",6798
6799// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)6800boxSizingNeeded = scrollboxSizeBuggy || extra,6801isBorderBox = boxSizingNeeded &&6802jQuery.css( elem, "boxSizing", false, styles ) === "border-box",6803subtract = extra ?6804boxModelAdjustment(6805elem,6806dimension,6807extra,6808isBorderBox,6809styles
6810) :68110;6812
6813// Account for unreliable border-box dimensions by comparing offset* to computed and6814// faking a content-box to get border and padding (gh-3699)6815if ( isBorderBox && scrollboxSizeBuggy ) {6816subtract -= Math.ceil(6817elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -6818parseFloat( styles[ dimension ] ) -6819boxModelAdjustment( elem, dimension, "border", false, styles ) -68200.56821);6822}6823
6824// Convert to pixels if value adjustment is needed6825if ( subtract && ( matches = rcssNum.exec( value ) ) &&6826( matches[ 3 ] || "px" ) !== "px" ) {6827
6828elem.style[ dimension ] = value;6829value = jQuery.css( elem, dimension );6830}6831
6832return setPositiveNumber( elem, value, subtract );6833}6834};6835} );6836
6837jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,6838function( elem, computed ) {6839if ( computed ) {6840return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||6841elem.getBoundingClientRect().left -6842swap( elem, { marginLeft: 0 }, function() {6843return elem.getBoundingClientRect().left;6844} )6845) + "px";6846}6847}6848);6849
6850// These hooks are used by animate to expand properties
6851jQuery.each( {6852margin: "",6853padding: "",6854border: "Width"6855}, function( prefix, suffix ) {6856jQuery.cssHooks[ prefix + suffix ] = {6857expand: function( value ) {6858var i = 0,6859expanded = {},6860
6861// Assumes a single number if not a string6862parts = typeof value === "string" ? value.split( " " ) : [ value ];6863
6864for ( ; i < 4; i++ ) {6865expanded[ prefix + cssExpand[ i ] + suffix ] =6866parts[ i ] || parts[ i - 2 ] || parts[ 0 ];6867}6868
6869return expanded;6870}6871};6872
6873if ( prefix !== "margin" ) {6874jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;6875}6876} );6877
6878jQuery.fn.extend( {6879css: function( name, value ) {6880return access( this, function( elem, name, value ) {6881var styles, len,6882map = {},6883i = 0;6884
6885if ( Array.isArray( name ) ) {6886styles = getStyles( elem );6887len = name.length;6888
6889for ( ; i < len; i++ ) {6890map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );6891}6892
6893return map;6894}6895
6896return value !== undefined ?6897jQuery.style( elem, name, value ) :6898jQuery.css( elem, name );6899}, name, value, arguments.length > 1 );6900}6901} );6902
6903
6904function Tween( elem, options, prop, end, easing ) {6905return new Tween.prototype.init( elem, options, prop, end, easing );6906}
6907jQuery.Tween = Tween;6908
6909Tween.prototype = {6910constructor: Tween,6911init: function( elem, options, prop, end, easing, unit ) {6912this.elem = elem;6913this.prop = prop;6914this.easing = easing || jQuery.easing._default;6915this.options = options;6916this.start = this.now = this.cur();6917this.end = end;6918this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );6919},6920cur: function() {6921var hooks = Tween.propHooks[ this.prop ];6922
6923return hooks && hooks.get ?6924hooks.get( this ) :6925Tween.propHooks._default.get( this );6926},6927run: function( percent ) {6928var eased,6929hooks = Tween.propHooks[ this.prop ];6930
6931if ( this.options.duration ) {6932this.pos = eased = jQuery.easing[ this.easing ](6933percent, this.options.duration * percent, 0, 1, this.options.duration6934);6935} else {6936this.pos = eased = percent;6937}6938this.now = ( this.end - this.start ) * eased + this.start;6939
6940if ( this.options.step ) {6941this.options.step.call( this.elem, this.now, this );6942}6943
6944if ( hooks && hooks.set ) {6945hooks.set( this );6946} else {6947Tween.propHooks._default.set( this );6948}6949return this;6950}6951};6952
6953Tween.prototype.init.prototype = Tween.prototype;6954
6955Tween.propHooks = {6956_default: {6957get: function( tween ) {6958var result;6959
6960// Use a property on the element directly when it is not a DOM element,6961// or when there is no matching style property that exists.6962if ( tween.elem.nodeType !== 1 ||6963tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {6964return tween.elem[ tween.prop ];6965}6966
6967// Passing an empty string as a 3rd parameter to .css will automatically6968// attempt a parseFloat and fallback to a string if the parse fails.6969// Simple values such as "10px" are parsed to Float;6970// complex values such as "rotate(1rad)" are returned as-is.6971result = jQuery.css( tween.elem, tween.prop, "" );6972
6973// Empty strings, null, undefined and "auto" are converted to 0.6974return !result || result === "auto" ? 0 : result;6975},6976set: function( tween ) {6977
6978// Use step hook for back compat.6979// Use cssHook if its there.6980// Use .style if available and use plain properties where available.6981if ( jQuery.fx.step[ tween.prop ] ) {6982jQuery.fx.step[ tween.prop ]( tween );6983} else if ( tween.elem.nodeType === 1 && (6984jQuery.cssHooks[ tween.prop ] ||6985tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {6986jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );6987} else {6988tween.elem[ tween.prop ] = tween.now;6989}6990}6991}6992};6993
6994// Support: IE <=9 only
6995// Panic based approach to setting things on disconnected nodes
6996Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {6997set: function( tween ) {6998if ( tween.elem.nodeType && tween.elem.parentNode ) {6999tween.elem[ tween.prop ] = tween.now;7000}7001}7002};7003
7004jQuery.easing = {7005linear: function( p ) {7006return p;7007},7008swing: function( p ) {7009return 0.5 - Math.cos( p * Math.PI ) / 2;7010},7011_default: "swing"7012};7013
7014jQuery.fx = Tween.prototype.init;7015
7016// Back compat <1.8 extension point
7017jQuery.fx.step = {};7018
7019
7020
7021
7022var
7023fxNow, inProgress,7024rfxtypes = /^(?:toggle|show|hide)$/,7025rrun = /queueHooks$/;7026
7027function schedule() {7028if ( inProgress ) {7029if ( document.hidden === false && window.requestAnimationFrame ) {7030window.requestAnimationFrame( schedule );7031} else {7032window.setTimeout( schedule, jQuery.fx.interval );7033}7034
7035jQuery.fx.tick();7036}7037}
7038
7039// Animations created synchronously will run synchronously
7040function createFxNow() {7041window.setTimeout( function() {7042fxNow = undefined;7043} );7044return ( fxNow = Date.now() );7045}
7046
7047// Generate parameters to create a standard animation
7048function genFx( type, includeWidth ) {7049var which,7050i = 0,7051attrs = { height: type };7052
7053// If we include width, step value is 1 to do all cssExpand values,7054// otherwise step value is 2 to skip over Left and Right7055includeWidth = includeWidth ? 1 : 0;7056for ( ; i < 4; i += 2 - includeWidth ) {7057which = cssExpand[ i ];7058attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;7059}7060
7061if ( includeWidth ) {7062attrs.opacity = attrs.width = type;7063}7064
7065return attrs;7066}
7067
7068function createTween( value, prop, animation ) {7069var tween,7070collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),7071index = 0,7072length = collection.length;7073for ( ; index < length; index++ ) {7074if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {7075
7076// We're done with this property7077return tween;7078}7079}7080}
7081
7082function defaultPrefilter( elem, props, opts ) {7083var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,7084isBox = "width" in props || "height" in props,7085anim = this,7086orig = {},7087style = elem.style,7088hidden = elem.nodeType && isHiddenWithinTree( elem ),7089dataShow = dataPriv.get( elem, "fxshow" );7090
7091// Queue-skipping animations hijack the fx hooks7092if ( !opts.queue ) {7093hooks = jQuery._queueHooks( elem, "fx" );7094if ( hooks.unqueued == null ) {7095hooks.unqueued = 0;7096oldfire = hooks.empty.fire;7097hooks.empty.fire = function() {7098if ( !hooks.unqueued ) {7099oldfire();7100}7101};7102}7103hooks.unqueued++;7104
7105anim.always( function() {7106
7107// Ensure the complete handler is called before this completes7108anim.always( function() {7109hooks.unqueued--;7110if ( !jQuery.queue( elem, "fx" ).length ) {7111hooks.empty.fire();7112}7113} );7114} );7115}7116
7117// Detect show/hide animations7118for ( prop in props ) {7119value = props[ prop ];7120if ( rfxtypes.test( value ) ) {7121delete props[ prop ];7122toggle = toggle || value === "toggle";7123if ( value === ( hidden ? "hide" : "show" ) ) {7124
7125// Pretend to be hidden if this is a "show" and7126// there is still data from a stopped show/hide7127if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {7128hidden = true;7129
7130// Ignore all other no-op show/hide data7131} else {7132continue;7133}7134}7135orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );7136}7137}7138
7139// Bail out if this is a no-op like .hide().hide()7140propTween = !jQuery.isEmptyObject( props );7141if ( !propTween && jQuery.isEmptyObject( orig ) ) {7142return;7143}7144
7145// Restrict "overflow" and "display" styles during box animations7146if ( isBox && elem.nodeType === 1 ) {7147
7148// Support: IE <=9 - 11, Edge 12 - 157149// Record all 3 overflow attributes because IE does not infer the shorthand7150// from identically-valued overflowX and overflowY and Edge just mirrors7151// the overflowX value there.7152opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];7153
7154// Identify a display type, preferring old show/hide data over the CSS cascade7155restoreDisplay = dataShow && dataShow.display;7156if ( restoreDisplay == null ) {7157restoreDisplay = dataPriv.get( elem, "display" );7158}7159display = jQuery.css( elem, "display" );7160if ( display === "none" ) {7161if ( restoreDisplay ) {7162display = restoreDisplay;7163} else {7164
7165// Get nonempty value(s) by temporarily forcing visibility7166showHide( [ elem ], true );7167restoreDisplay = elem.style.display || restoreDisplay;7168display = jQuery.css( elem, "display" );7169showHide( [ elem ] );7170}7171}7172
7173// Animate inline elements as inline-block7174if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {7175if ( jQuery.css( elem, "float" ) === "none" ) {7176
7177// Restore the original display value at the end of pure show/hide animations7178if ( !propTween ) {7179anim.done( function() {7180style.display = restoreDisplay;7181} );7182if ( restoreDisplay == null ) {7183display = style.display;7184restoreDisplay = display === "none" ? "" : display;7185}7186}7187style.display = "inline-block";7188}7189}7190}7191
7192if ( opts.overflow ) {7193style.overflow = "hidden";7194anim.always( function() {7195style.overflow = opts.overflow[ 0 ];7196style.overflowX = opts.overflow[ 1 ];7197style.overflowY = opts.overflow[ 2 ];7198} );7199}7200
7201// Implement show/hide animations7202propTween = false;7203for ( prop in orig ) {7204
7205// General show/hide setup for this element animation7206if ( !propTween ) {7207if ( dataShow ) {7208if ( "hidden" in dataShow ) {7209hidden = dataShow.hidden;7210}7211} else {7212dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );7213}7214
7215// Store hidden/visible for toggle so `.stop().toggle()` "reverses"7216if ( toggle ) {7217dataShow.hidden = !hidden;7218}7219
7220// Show elements before animating them7221if ( hidden ) {7222showHide( [ elem ], true );7223}7224
7225/* eslint-disable no-loop-func */7226
7227anim.done( function() {7228
7229/* eslint-enable no-loop-func */7230
7231// The final step of a "hide" animation is actually hiding the element7232if ( !hidden ) {7233showHide( [ elem ] );7234}7235dataPriv.remove( elem, "fxshow" );7236for ( prop in orig ) {7237jQuery.style( elem, prop, orig[ prop ] );7238}7239} );7240}7241
7242// Per-property setup7243propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );7244if ( !( prop in dataShow ) ) {7245dataShow[ prop ] = propTween.start;7246if ( hidden ) {7247propTween.end = propTween.start;7248propTween.start = 0;7249}7250}7251}7252}
7253
7254function propFilter( props, specialEasing ) {7255var index, name, easing, value, hooks;7256
7257// camelCase, specialEasing and expand cssHook pass7258for ( index in props ) {7259name = camelCase( index );7260easing = specialEasing[ name ];7261value = props[ index ];7262if ( Array.isArray( value ) ) {7263easing = value[ 1 ];7264value = props[ index ] = value[ 0 ];7265}7266
7267if ( index !== name ) {7268props[ name ] = value;7269delete props[ index ];7270}7271
7272hooks = jQuery.cssHooks[ name ];7273if ( hooks && "expand" in hooks ) {7274value = hooks.expand( value );7275delete props[ name ];7276
7277// Not quite $.extend, this won't overwrite existing keys.7278// Reusing 'index' because we have the correct "name"7279for ( index in value ) {7280if ( !( index in props ) ) {7281props[ index ] = value[ index ];7282specialEasing[ index ] = easing;7283}7284}7285} else {7286specialEasing[ name ] = easing;7287}7288}7289}
7290
7291function Animation( elem, properties, options ) {7292var result,7293stopped,7294index = 0,7295length = Animation.prefilters.length,7296deferred = jQuery.Deferred().always( function() {7297
7298// Don't match elem in the :animated selector7299delete tick.elem;7300} ),7301tick = function() {7302if ( stopped ) {7303return false;7304}7305var currentTime = fxNow || createFxNow(),7306remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),7307
7308// Support: Android 2.3 only7309// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)7310temp = remaining / animation.duration || 0,7311percent = 1 - temp,7312index = 0,7313length = animation.tweens.length;7314
7315for ( ; index < length; index++ ) {7316animation.tweens[ index ].run( percent );7317}7318
7319deferred.notifyWith( elem, [ animation, percent, remaining ] );7320
7321// If there's more to do, yield7322if ( percent < 1 && length ) {7323return remaining;7324}7325
7326// If this was an empty animation, synthesize a final progress notification7327if ( !length ) {7328deferred.notifyWith( elem, [ animation, 1, 0 ] );7329}7330
7331// Resolve the animation and report its conclusion7332deferred.resolveWith( elem, [ animation ] );7333return false;7334},7335animation = deferred.promise( {7336elem: elem,7337props: jQuery.extend( {}, properties ),7338opts: jQuery.extend( true, {7339specialEasing: {},7340easing: jQuery.easing._default7341}, options ),7342originalProperties: properties,7343originalOptions: options,7344startTime: fxNow || createFxNow(),7345duration: options.duration,7346tweens: [],7347createTween: function( prop, end ) {7348var tween = jQuery.Tween( elem, animation.opts, prop, end,7349animation.opts.specialEasing[ prop ] || animation.opts.easing );7350animation.tweens.push( tween );7351return tween;7352},7353stop: function( gotoEnd ) {7354var index = 0,7355
7356// If we are going to the end, we want to run all the tweens7357// otherwise we skip this part7358length = gotoEnd ? animation.tweens.length : 0;7359if ( stopped ) {7360return this;7361}7362stopped = true;7363for ( ; index < length; index++ ) {7364animation.tweens[ index ].run( 1 );7365}7366
7367// Resolve when we played the last frame; otherwise, reject7368if ( gotoEnd ) {7369deferred.notifyWith( elem, [ animation, 1, 0 ] );7370deferred.resolveWith( elem, [ animation, gotoEnd ] );7371} else {7372deferred.rejectWith( elem, [ animation, gotoEnd ] );7373}7374return this;7375}7376} ),7377props = animation.props;7378
7379propFilter( props, animation.opts.specialEasing );7380
7381for ( ; index < length; index++ ) {7382result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );7383if ( result ) {7384if ( isFunction( result.stop ) ) {7385jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =7386result.stop.bind( result );7387}7388return result;7389}7390}7391
7392jQuery.map( props, createTween, animation );7393
7394if ( isFunction( animation.opts.start ) ) {7395animation.opts.start.call( elem, animation );7396}7397
7398// Attach callbacks from options7399animation
7400.progress( animation.opts.progress )7401.done( animation.opts.done, animation.opts.complete )7402.fail( animation.opts.fail )7403.always( animation.opts.always );7404
7405jQuery.fx.timer(7406jQuery.extend( tick, {7407elem: elem,7408anim: animation,7409queue: animation.opts.queue7410} )7411);7412
7413return animation;7414}
7415
7416jQuery.Animation = jQuery.extend( Animation, {7417
7418tweeners: {7419"*": [ function( prop, value ) {7420var tween = this.createTween( prop, value );7421adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );7422return tween;7423} ]7424},7425
7426tweener: function( props, callback ) {7427if ( isFunction( props ) ) {7428callback = props;7429props = [ "*" ];7430} else {7431props = props.match( rnothtmlwhite );7432}7433
7434var prop,7435index = 0,7436length = props.length;7437
7438for ( ; index < length; index++ ) {7439prop = props[ index ];7440Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];7441Animation.tweeners[ prop ].unshift( callback );7442}7443},7444
7445prefilters: [ defaultPrefilter ],7446
7447prefilter: function( callback, prepend ) {7448if ( prepend ) {7449Animation.prefilters.unshift( callback );7450} else {7451Animation.prefilters.push( callback );7452}7453}7454} );7455
7456jQuery.speed = function( speed, easing, fn ) {7457var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {7458complete: fn || !fn && easing ||7459isFunction( speed ) && speed,7460duration: speed,7461easing: fn && easing || easing && !isFunction( easing ) && easing7462};7463
7464// Go to the end state if fx are off7465if ( jQuery.fx.off ) {7466opt.duration = 0;7467
7468} else {7469if ( typeof opt.duration !== "number" ) {7470if ( opt.duration in jQuery.fx.speeds ) {7471opt.duration = jQuery.fx.speeds[ opt.duration ];7472
7473} else {7474opt.duration = jQuery.fx.speeds._default;7475}7476}7477}7478
7479// Normalize opt.queue - true/undefined/null -> "fx"7480if ( opt.queue == null || opt.queue === true ) {7481opt.queue = "fx";7482}7483
7484// Queueing7485opt.old = opt.complete;7486
7487opt.complete = function() {7488if ( isFunction( opt.old ) ) {7489opt.old.call( this );7490}7491
7492if ( opt.queue ) {7493jQuery.dequeue( this, opt.queue );7494}7495};7496
7497return opt;7498};7499
7500jQuery.fn.extend( {7501fadeTo: function( speed, to, easing, callback ) {7502
7503// Show any hidden elements after setting opacity to 07504return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()7505
7506// Animate to the value specified7507.end().animate( { opacity: to }, speed, easing, callback );7508},7509animate: function( prop, speed, easing, callback ) {7510var empty = jQuery.isEmptyObject( prop ),7511optall = jQuery.speed( speed, easing, callback ),7512doAnimation = function() {7513
7514// Operate on a copy of prop so per-property easing won't be lost7515var anim = Animation( this, jQuery.extend( {}, prop ), optall );7516
7517// Empty animations, or finishing resolves immediately7518if ( empty || dataPriv.get( this, "finish" ) ) {7519anim.stop( true );7520}7521};7522doAnimation.finish = doAnimation;7523
7524return empty || optall.queue === false ?7525this.each( doAnimation ) :7526this.queue( optall.queue, doAnimation );7527},7528stop: function( type, clearQueue, gotoEnd ) {7529var stopQueue = function( hooks ) {7530var stop = hooks.stop;7531delete hooks.stop;7532stop( gotoEnd );7533};7534
7535if ( typeof type !== "string" ) {7536gotoEnd = clearQueue;7537clearQueue = type;7538type = undefined;7539}7540if ( clearQueue && type !== false ) {7541this.queue( type || "fx", [] );7542}7543
7544return this.each( function() {7545var dequeue = true,7546index = type != null && type + "queueHooks",7547timers = jQuery.timers,7548data = dataPriv.get( this );7549
7550if ( index ) {7551if ( data[ index ] && data[ index ].stop ) {7552stopQueue( data[ index ] );7553}7554} else {7555for ( index in data ) {7556if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {7557stopQueue( data[ index ] );7558}7559}7560}7561
7562for ( index = timers.length; index--; ) {7563if ( timers[ index ].elem === this &&7564( type == null || timers[ index ].queue === type ) ) {7565
7566timers[ index ].anim.stop( gotoEnd );7567dequeue = false;7568timers.splice( index, 1 );7569}7570}7571
7572// Start the next in the queue if the last step wasn't forced.7573// Timers currently will call their complete callbacks, which7574// will dequeue but only if they were gotoEnd.7575if ( dequeue || !gotoEnd ) {7576jQuery.dequeue( this, type );7577}7578} );7579},7580finish: function( type ) {7581if ( type !== false ) {7582type = type || "fx";7583}7584return this.each( function() {7585var index,7586data = dataPriv.get( this ),7587queue = data[ type + "queue" ],7588hooks = data[ type + "queueHooks" ],7589timers = jQuery.timers,7590length = queue ? queue.length : 0;7591
7592// Enable finishing flag on private data7593data.finish = true;7594
7595// Empty the queue first7596jQuery.queue( this, type, [] );7597
7598if ( hooks && hooks.stop ) {7599hooks.stop.call( this, true );7600}7601
7602// Look for any active animations, and finish them7603for ( index = timers.length; index--; ) {7604if ( timers[ index ].elem === this && timers[ index ].queue === type ) {7605timers[ index ].anim.stop( true );7606timers.splice( index, 1 );7607}7608}7609
7610// Look for any animations in the old queue and finish them7611for ( index = 0; index < length; index++ ) {7612if ( queue[ index ] && queue[ index ].finish ) {7613queue[ index ].finish.call( this );7614}7615}7616
7617// Turn off finishing flag7618delete data.finish;7619} );7620}7621} );7622
7623jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {7624var cssFn = jQuery.fn[ name ];7625jQuery.fn[ name ] = function( speed, easing, callback ) {7626return speed == null || typeof speed === "boolean" ?7627cssFn.apply( this, arguments ) :7628this.animate( genFx( name, true ), speed, easing, callback );7629};7630} );7631
7632// Generate shortcuts for custom animations
7633jQuery.each( {7634slideDown: genFx( "show" ),7635slideUp: genFx( "hide" ),7636slideToggle: genFx( "toggle" ),7637fadeIn: { opacity: "show" },7638fadeOut: { opacity: "hide" },7639fadeToggle: { opacity: "toggle" }7640}, function( name, props ) {7641jQuery.fn[ name ] = function( speed, easing, callback ) {7642return this.animate( props, speed, easing, callback );7643};7644} );7645
7646jQuery.timers = [];7647jQuery.fx.tick = function() {7648var timer,7649i = 0,7650timers = jQuery.timers;7651
7652fxNow = Date.now();7653
7654for ( ; i < timers.length; i++ ) {7655timer = timers[ i ];7656
7657// Run the timer and safely remove it when done (allowing for external removal)7658if ( !timer() && timers[ i ] === timer ) {7659timers.splice( i--, 1 );7660}7661}7662
7663if ( !timers.length ) {7664jQuery.fx.stop();7665}7666fxNow = undefined;7667};7668
7669jQuery.fx.timer = function( timer ) {7670jQuery.timers.push( timer );7671jQuery.fx.start();7672};7673
7674jQuery.fx.interval = 13;7675jQuery.fx.start = function() {7676if ( inProgress ) {7677return;7678}7679
7680inProgress = true;7681schedule();7682};7683
7684jQuery.fx.stop = function() {7685inProgress = null;7686};7687
7688jQuery.fx.speeds = {7689slow: 600,7690fast: 200,7691
7692// Default speed7693_default: 4007694};7695
7696
7697// Based off of the plugin by Clint Helfers, with permission.
7698// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
7699jQuery.fn.delay = function( time, type ) {7700time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;7701type = type || "fx";7702
7703return this.queue( type, function( next, hooks ) {7704var timeout = window.setTimeout( next, time );7705hooks.stop = function() {7706window.clearTimeout( timeout );7707};7708} );7709};7710
7711
7712( function() {7713var input = document.createElement( "input" ),7714select = document.createElement( "select" ),7715opt = select.appendChild( document.createElement( "option" ) );7716
7717input.type = "checkbox";7718
7719// Support: Android <=4.3 only7720// Default value for a checkbox should be "on"7721support.checkOn = input.value !== "";7722
7723// Support: IE <=11 only7724// Must access selectedIndex to make default options select7725support.optSelected = opt.selected;7726
7727// Support: IE <=11 only7728// An input loses its value after becoming a radio7729input = document.createElement( "input" );7730input.value = "t";7731input.type = "radio";7732support.radioValue = input.value === "t";7733} )();7734
7735
7736var boolHook,7737attrHandle = jQuery.expr.attrHandle;7738
7739jQuery.fn.extend( {7740attr: function( name, value ) {7741return access( this, jQuery.attr, name, value, arguments.length > 1 );7742},7743
7744removeAttr: function( name ) {7745return this.each( function() {7746jQuery.removeAttr( this, name );7747} );7748}7749} );7750
7751jQuery.extend( {7752attr: function( elem, name, value ) {7753var ret, hooks,7754nType = elem.nodeType;7755
7756// Don't get/set attributes on text, comment and attribute nodes7757if ( nType === 3 || nType === 8 || nType === 2 ) {7758return;7759}7760
7761// Fallback to prop when attributes are not supported7762if ( typeof elem.getAttribute === "undefined" ) {7763return jQuery.prop( elem, name, value );7764}7765
7766// Attribute hooks are determined by the lowercase version7767// Grab necessary hook if one is defined7768if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {7769hooks = jQuery.attrHooks[ name.toLowerCase() ] ||7770( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );7771}7772
7773if ( value !== undefined ) {7774if ( value === null ) {7775jQuery.removeAttr( elem, name );7776return;7777}7778
7779if ( hooks && "set" in hooks &&7780( ret = hooks.set( elem, value, name ) ) !== undefined ) {7781return ret;7782}7783
7784elem.setAttribute( name, value + "" );7785return value;7786}7787
7788if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {7789return ret;7790}7791
7792ret = jQuery.find.attr( elem, name );7793
7794// Non-existent attributes return null, we normalize to undefined7795return ret == null ? undefined : ret;7796},7797
7798attrHooks: {7799type: {7800set: function( elem, value ) {7801if ( !support.radioValue && value === "radio" &&7802nodeName( elem, "input" ) ) {7803var val = elem.value;7804elem.setAttribute( "type", value );7805if ( val ) {7806elem.value = val;7807}7808return value;7809}7810}7811}7812},7813
7814removeAttr: function( elem, value ) {7815var name,7816i = 0,7817
7818// Attribute names can contain non-HTML whitespace characters7819// https://html.spec.whatwg.org/multipage/syntax.html#attributes-27820attrNames = value && value.match( rnothtmlwhite );7821
7822if ( attrNames && elem.nodeType === 1 ) {7823while ( ( name = attrNames[ i++ ] ) ) {7824elem.removeAttribute( name );7825}7826}7827}7828} );7829
7830// Hooks for boolean attributes
7831boolHook = {7832set: function( elem, value, name ) {7833if ( value === false ) {7834
7835// Remove boolean attributes when set to false7836jQuery.removeAttr( elem, name );7837} else {7838elem.setAttribute( name, name );7839}7840return name;7841}7842};7843
7844jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {7845var getter = attrHandle[ name ] || jQuery.find.attr;7846
7847attrHandle[ name ] = function( elem, name, isXML ) {7848var ret, handle,7849lowercaseName = name.toLowerCase();7850
7851if ( !isXML ) {7852
7853// Avoid an infinite loop by temporarily removing this function from the getter7854handle = attrHandle[ lowercaseName ];7855attrHandle[ lowercaseName ] = ret;7856ret = getter( elem, name, isXML ) != null ?7857lowercaseName :7858null;7859attrHandle[ lowercaseName ] = handle;7860}7861return ret;7862};7863} );7864
7865
7866
7867
7868var rfocusable = /^(?:input|select|textarea|button)$/i,7869rclickable = /^(?:a|area)$/i;7870
7871jQuery.fn.extend( {7872prop: function( name, value ) {7873return access( this, jQuery.prop, name, value, arguments.length > 1 );7874},7875
7876removeProp: function( name ) {7877return this.each( function() {7878delete this[ jQuery.propFix[ name ] || name ];7879} );7880}7881} );7882
7883jQuery.extend( {7884prop: function( elem, name, value ) {7885var ret, hooks,7886nType = elem.nodeType;7887
7888// Don't get/set properties on text, comment and attribute nodes7889if ( nType === 3 || nType === 8 || nType === 2 ) {7890return;7891}7892
7893if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {7894
7895// Fix name and attach hooks7896name = jQuery.propFix[ name ] || name;7897hooks = jQuery.propHooks[ name ];7898}7899
7900if ( value !== undefined ) {7901if ( hooks && "set" in hooks &&7902( ret = hooks.set( elem, value, name ) ) !== undefined ) {7903return ret;7904}7905
7906return ( elem[ name ] = value );7907}7908
7909if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {7910return ret;7911}7912
7913return elem[ name ];7914},7915
7916propHooks: {7917tabIndex: {7918get: function( elem ) {7919
7920// Support: IE <=9 - 11 only7921// elem.tabIndex doesn't always return the7922// correct value when it hasn't been explicitly set7923// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/7924// Use proper attribute retrieval(#12072)7925var tabindex = jQuery.find.attr( elem, "tabindex" );7926
7927if ( tabindex ) {7928return parseInt( tabindex, 10 );7929}7930
7931if (7932rfocusable.test( elem.nodeName ) ||7933rclickable.test( elem.nodeName ) &&7934elem.href7935) {7936return 0;7937}7938
7939return -1;7940}7941}7942},7943
7944propFix: {7945"for": "htmlFor",7946"class": "className"7947}7948} );7949
7950// Support: IE <=11 only
7951// Accessing the selectedIndex property
7952// forces the browser to respect setting selected
7953// on the option
7954// The getter ensures a default option is selected
7955// when in an optgroup
7956// eslint rule "no-unused-expressions" is disabled for this code
7957// since it considers such accessions noop
7958if ( !support.optSelected ) {7959jQuery.propHooks.selected = {7960get: function( elem ) {7961
7962/* eslint no-unused-expressions: "off" */7963
7964var parent = elem.parentNode;7965if ( parent && parent.parentNode ) {7966parent.parentNode.selectedIndex;7967}7968return null;7969},7970set: function( elem ) {7971
7972/* eslint no-unused-expressions: "off" */7973
7974var parent = elem.parentNode;7975if ( parent ) {7976parent.selectedIndex;7977
7978if ( parent.parentNode ) {7979parent.parentNode.selectedIndex;7980}7981}7982}7983};7984}
7985
7986jQuery.each( [7987"tabIndex",7988"readOnly",7989"maxLength",7990"cellSpacing",7991"cellPadding",7992"rowSpan",7993"colSpan",7994"useMap",7995"frameBorder",7996"contentEditable"7997], function() {7998jQuery.propFix[ this.toLowerCase() ] = this;7999} );8000
8001
8002
8003
8004// Strip and collapse whitespace according to HTML spec8005// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace8006function stripAndCollapse( value ) {8007var tokens = value.match( rnothtmlwhite ) || [];8008return tokens.join( " " );8009}8010
8011
8012function getClass( elem ) {8013return elem.getAttribute && elem.getAttribute( "class" ) || "";8014}
8015
8016function classesToArray( value ) {8017if ( Array.isArray( value ) ) {8018return value;8019}8020if ( typeof value === "string" ) {8021return value.match( rnothtmlwhite ) || [];8022}8023return [];8024}
8025
8026jQuery.fn.extend( {8027addClass: function( value ) {8028var classes, elem, cur, curValue, clazz, j, finalValue,8029i = 0;8030
8031if ( isFunction( value ) ) {8032return this.each( function( j ) {8033jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );8034} );8035}8036
8037classes = classesToArray( value );8038
8039if ( classes.length ) {8040while ( ( elem = this[ i++ ] ) ) {8041curValue = getClass( elem );8042cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );8043
8044if ( cur ) {8045j = 0;8046while ( ( clazz = classes[ j++ ] ) ) {8047if ( cur.indexOf( " " + clazz + " " ) < 0 ) {8048cur += clazz + " ";8049}8050}8051
8052// Only assign if different to avoid unneeded rendering.8053finalValue = stripAndCollapse( cur );8054if ( curValue !== finalValue ) {8055elem.setAttribute( "class", finalValue );8056}8057}8058}8059}8060
8061return this;8062},8063
8064removeClass: function( value ) {8065var classes, elem, cur, curValue, clazz, j, finalValue,8066i = 0;8067
8068if ( isFunction( value ) ) {8069return this.each( function( j ) {8070jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );8071} );8072}8073
8074if ( !arguments.length ) {8075return this.attr( "class", "" );8076}8077
8078classes = classesToArray( value );8079
8080if ( classes.length ) {8081while ( ( elem = this[ i++ ] ) ) {8082curValue = getClass( elem );8083
8084// This expression is here for better compressibility (see addClass)8085cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );8086
8087if ( cur ) {8088j = 0;8089while ( ( clazz = classes[ j++ ] ) ) {8090
8091// Remove *all* instances8092while ( cur.indexOf( " " + clazz + " " ) > -1 ) {8093cur = cur.replace( " " + clazz + " ", " " );8094}8095}8096
8097// Only assign if different to avoid unneeded rendering.8098finalValue = stripAndCollapse( cur );8099if ( curValue !== finalValue ) {8100elem.setAttribute( "class", finalValue );8101}8102}8103}8104}8105
8106return this;8107},8108
8109toggleClass: function( value, stateVal ) {8110var type = typeof value,8111isValidValue = type === "string" || Array.isArray( value );8112
8113if ( typeof stateVal === "boolean" && isValidValue ) {8114return stateVal ? this.addClass( value ) : this.removeClass( value );8115}8116
8117if ( isFunction( value ) ) {8118return this.each( function( i ) {8119jQuery( this ).toggleClass(8120value.call( this, i, getClass( this ), stateVal ),8121stateVal
8122);8123} );8124}8125
8126return this.each( function() {8127var className, i, self, classNames;8128
8129if ( isValidValue ) {8130
8131// Toggle individual class names8132i = 0;8133self = jQuery( this );8134classNames = classesToArray( value );8135
8136while ( ( className = classNames[ i++ ] ) ) {8137
8138// Check each className given, space separated list8139if ( self.hasClass( className ) ) {8140self.removeClass( className );8141} else {8142self.addClass( className );8143}8144}8145
8146// Toggle whole class name8147} else if ( value === undefined || type === "boolean" ) {8148className = getClass( this );8149if ( className ) {8150
8151// Store className if set8152dataPriv.set( this, "__className__", className );8153}8154
8155// If the element has a class name or if we're passed `false`,8156// then remove the whole classname (if there was one, the above saved it).8157// Otherwise bring back whatever was previously saved (if anything),8158// falling back to the empty string if nothing was stored.8159if ( this.setAttribute ) {8160this.setAttribute( "class",8161className || value === false ?8162"" :8163dataPriv.get( this, "__className__" ) || ""8164);8165}8166}8167} );8168},8169
8170hasClass: function( selector ) {8171var className, elem,8172i = 0;8173
8174className = " " + selector + " ";8175while ( ( elem = this[ i++ ] ) ) {8176if ( elem.nodeType === 1 &&8177( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {8178return true;8179}8180}8181
8182return false;8183}8184} );8185
8186
8187
8188
8189var rreturn = /\r/g;8190
8191jQuery.fn.extend( {8192val: function( value ) {8193var hooks, ret, valueIsFunction,8194elem = this[ 0 ];8195
8196if ( !arguments.length ) {8197if ( elem ) {8198hooks = jQuery.valHooks[ elem.type ] ||8199jQuery.valHooks[ elem.nodeName.toLowerCase() ];8200
8201if ( hooks &&8202"get" in hooks &&8203( ret = hooks.get( elem, "value" ) ) !== undefined8204) {8205return ret;8206}8207
8208ret = elem.value;8209
8210// Handle most common string cases8211if ( typeof ret === "string" ) {8212return ret.replace( rreturn, "" );8213}8214
8215// Handle cases where value is null/undef or number8216return ret == null ? "" : ret;8217}8218
8219return;8220}8221
8222valueIsFunction = isFunction( value );8223
8224return this.each( function( i ) {8225var val;8226
8227if ( this.nodeType !== 1 ) {8228return;8229}8230
8231if ( valueIsFunction ) {8232val = value.call( this, i, jQuery( this ).val() );8233} else {8234val = value;8235}8236
8237// Treat null/undefined as ""; convert numbers to string8238if ( val == null ) {8239val = "";8240
8241} else if ( typeof val === "number" ) {8242val += "";8243
8244} else if ( Array.isArray( val ) ) {8245val = jQuery.map( val, function( value ) {8246return value == null ? "" : value + "";8247} );8248}8249
8250hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];8251
8252// If set returns undefined, fall back to normal setting8253if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {8254this.value = val;8255}8256} );8257}8258} );8259
8260jQuery.extend( {8261valHooks: {8262option: {8263get: function( elem ) {8264
8265var val = jQuery.find.attr( elem, "value" );8266return val != null ?8267val :8268
8269// Support: IE <=10 - 11 only8270// option.text throws exceptions (#14686, #14858)8271// Strip and collapse whitespace8272// https://html.spec.whatwg.org/#strip-and-collapse-whitespace8273stripAndCollapse( jQuery.text( elem ) );8274}8275},8276select: {8277get: function( elem ) {8278var value, option, i,8279options = elem.options,8280index = elem.selectedIndex,8281one = elem.type === "select-one",8282values = one ? null : [],8283max = one ? index + 1 : options.length;8284
8285if ( index < 0 ) {8286i = max;8287
8288} else {8289i = one ? index : 0;8290}8291
8292// Loop through all the selected options8293for ( ; i < max; i++ ) {8294option = options[ i ];8295
8296// Support: IE <=9 only8297// IE8-9 doesn't update selected after form reset (#2551)8298if ( ( option.selected || i === index ) &&8299
8300// Don't return options that are disabled or in a disabled optgroup8301!option.disabled &&8302( !option.parentNode.disabled ||8303!nodeName( option.parentNode, "optgroup" ) ) ) {8304
8305// Get the specific value for the option8306value = jQuery( option ).val();8307
8308// We don't need an array for one selects8309if ( one ) {8310return value;8311}8312
8313// Multi-Selects return an array8314values.push( value );8315}8316}8317
8318return values;8319},8320
8321set: function( elem, value ) {8322var optionSet, option,8323options = elem.options,8324values = jQuery.makeArray( value ),8325i = options.length;8326
8327while ( i-- ) {8328option = options[ i ];8329
8330/* eslint-disable no-cond-assign */8331
8332if ( option.selected =8333jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -18334) {8335optionSet = true;8336}8337
8338/* eslint-enable no-cond-assign */8339}8340
8341// Force browsers to behave consistently when non-matching value is set8342if ( !optionSet ) {8343elem.selectedIndex = -1;8344}8345return values;8346}8347}8348}8349} );8350
8351// Radios and checkboxes getter/setter
8352jQuery.each( [ "radio", "checkbox" ], function() {8353jQuery.valHooks[ this ] = {8354set: function( elem, value ) {8355if ( Array.isArray( value ) ) {8356return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );8357}8358}8359};8360if ( !support.checkOn ) {8361jQuery.valHooks[ this ].get = function( elem ) {8362return elem.getAttribute( "value" ) === null ? "on" : elem.value;8363};8364}8365} );8366
8367
8368
8369
8370// Return jQuery for attributes-only inclusion
8371
8372
8373support.focusin = "onfocusin" in window;8374
8375
8376var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,8377stopPropagationCallback = function( e ) {8378e.stopPropagation();8379};8380
8381jQuery.extend( jQuery.event, {8382
8383trigger: function( event, data, elem, onlyHandlers ) {8384
8385var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,8386eventPath = [ elem || document ],8387type = hasOwn.call( event, "type" ) ? event.type : event,8388namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];8389
8390cur = lastElement = tmp = elem = elem || document;8391
8392// Don't do events on text and comment nodes8393if ( elem.nodeType === 3 || elem.nodeType === 8 ) {8394return;8395}8396
8397// focus/blur morphs to focusin/out; ensure we're not firing them right now8398if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {8399return;8400}8401
8402if ( type.indexOf( "." ) > -1 ) {8403
8404// Namespaced trigger; create a regexp to match event type in handle()8405namespaces = type.split( "." );8406type = namespaces.shift();8407namespaces.sort();8408}8409ontype = type.indexOf( ":" ) < 0 && "on" + type;8410
8411// Caller can pass in a jQuery.Event object, Object, or just an event type string8412event = event[ jQuery.expando ] ?8413event :8414new jQuery.Event( type, typeof event === "object" && event );8415
8416// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)8417event.isTrigger = onlyHandlers ? 2 : 3;8418event.namespace = namespaces.join( "." );8419event.rnamespace = event.namespace ?8420new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :8421null;8422
8423// Clean up the event in case it is being reused8424event.result = undefined;8425if ( !event.target ) {8426event.target = elem;8427}8428
8429// Clone any incoming data and prepend the event, creating the handler arg list8430data = data == null ?8431[ event ] :8432jQuery.makeArray( data, [ event ] );8433
8434// Allow special events to draw outside the lines8435special = jQuery.event.special[ type ] || {};8436if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {8437return;8438}8439
8440// Determine event propagation path in advance, per W3C events spec (#9951)8441// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)8442if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {8443
8444bubbleType = special.delegateType || type;8445if ( !rfocusMorph.test( bubbleType + type ) ) {8446cur = cur.parentNode;8447}8448for ( ; cur; cur = cur.parentNode ) {8449eventPath.push( cur );8450tmp = cur;8451}8452
8453// Only add window if we got to document (e.g., not plain obj or detached DOM)8454if ( tmp === ( elem.ownerDocument || document ) ) {8455eventPath.push( tmp.defaultView || tmp.parentWindow || window );8456}8457}8458
8459// Fire handlers on the event path8460i = 0;8461while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {8462lastElement = cur;8463event.type = i > 1 ?8464bubbleType :8465special.bindType || type;8466
8467// jQuery handler8468handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&8469dataPriv.get( cur, "handle" );8470if ( handle ) {8471handle.apply( cur, data );8472}8473
8474// Native handler8475handle = ontype && cur[ ontype ];8476if ( handle && handle.apply && acceptData( cur ) ) {8477event.result = handle.apply( cur, data );8478if ( event.result === false ) {8479event.preventDefault();8480}8481}8482}8483event.type = type;8484
8485// If nobody prevented the default action, do it now8486if ( !onlyHandlers && !event.isDefaultPrevented() ) {8487
8488if ( ( !special._default ||8489special._default.apply( eventPath.pop(), data ) === false ) &&8490acceptData( elem ) ) {8491
8492// Call a native DOM method on the target with the same name as the event.8493// Don't do default actions on window, that's where global variables be (#6170)8494if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {8495
8496// Don't re-trigger an onFOO event when we call its FOO() method8497tmp = elem[ ontype ];8498
8499if ( tmp ) {8500elem[ ontype ] = null;8501}8502
8503// Prevent re-triggering of the same event, since we already bubbled it above8504jQuery.event.triggered = type;8505
8506if ( event.isPropagationStopped() ) {8507lastElement.addEventListener( type, stopPropagationCallback );8508}8509
8510elem[ type ]();8511
8512if ( event.isPropagationStopped() ) {8513lastElement.removeEventListener( type, stopPropagationCallback );8514}8515
8516jQuery.event.triggered = undefined;8517
8518if ( tmp ) {8519elem[ ontype ] = tmp;8520}8521}8522}8523}8524
8525return event.result;8526},8527
8528// Piggyback on a donor event to simulate a different one8529// Used only for `focus(in | out)` events8530simulate: function( type, elem, event ) {8531var e = jQuery.extend(8532new jQuery.Event(),8533event,8534{8535type: type,8536isSimulated: true8537}8538);8539
8540jQuery.event.trigger( e, null, elem );8541}8542
8543} );8544
8545jQuery.fn.extend( {8546
8547trigger: function( type, data ) {8548return this.each( function() {8549jQuery.event.trigger( type, data, this );8550} );8551},8552triggerHandler: function( type, data ) {8553var elem = this[ 0 ];8554if ( elem ) {8555return jQuery.event.trigger( type, data, elem, true );8556}8557}8558} );8559
8560
8561// Support: Firefox <=44
8562// Firefox doesn't have focus(in | out) events
8563// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
8564//
8565// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
8566// focus(in | out) events fire after focus & blur events,
8567// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
8568// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
8569if ( !support.focusin ) {8570jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {8571
8572// Attach a single capturing handler on the document while someone wants focusin/focusout8573var handler = function( event ) {8574jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );8575};8576
8577jQuery.event.special[ fix ] = {8578setup: function() {8579var doc = this.ownerDocument || this,8580attaches = dataPriv.access( doc, fix );8581
8582if ( !attaches ) {8583doc.addEventListener( orig, handler, true );8584}8585dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );8586},8587teardown: function() {8588var doc = this.ownerDocument || this,8589attaches = dataPriv.access( doc, fix ) - 1;8590
8591if ( !attaches ) {8592doc.removeEventListener( orig, handler, true );8593dataPriv.remove( doc, fix );8594
8595} else {8596dataPriv.access( doc, fix, attaches );8597}8598}8599};8600} );8601}
8602var location = window.location;8603
8604var nonce = Date.now();8605
8606var rquery = ( /\?/ );8607
8608
8609
8610// Cross-browser xml parsing
8611jQuery.parseXML = function( data ) {8612var xml;8613if ( !data || typeof data !== "string" ) {8614return null;8615}8616
8617// Support: IE 9 - 11 only8618// IE throws on parseFromString with invalid input.8619try {8620xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );8621} catch ( e ) {8622xml = undefined;8623}8624
8625if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {8626jQuery.error( "Invalid XML: " + data );8627}8628return xml;8629};8630
8631
8632var
8633rbracket = /\[\]$/,8634rCRLF = /\r?\n/g,8635rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,8636rsubmittable = /^(?:input|select|textarea|keygen)/i;8637
8638function buildParams( prefix, obj, traditional, add ) {8639var name;8640
8641if ( Array.isArray( obj ) ) {8642
8643// Serialize array item.8644jQuery.each( obj, function( i, v ) {8645if ( traditional || rbracket.test( prefix ) ) {8646
8647// Treat each array item as a scalar.8648add( prefix, v );8649
8650} else {8651
8652// Item is non-scalar (array or object), encode its numeric index.8653buildParams(8654prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",8655v,8656traditional,8657add
8658);8659}8660} );8661
8662} else if ( !traditional && toType( obj ) === "object" ) {8663
8664// Serialize object item.8665for ( name in obj ) {8666buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );8667}8668
8669} else {8670
8671// Serialize scalar item.8672add( prefix, obj );8673}8674}
8675
8676// Serialize an array of form elements or a set of
8677// key/values into a query string
8678jQuery.param = function( a, traditional ) {8679var prefix,8680s = [],8681add = function( key, valueOrFunction ) {8682
8683// If value is a function, invoke it and use its return value8684var value = isFunction( valueOrFunction ) ?8685valueOrFunction() :8686valueOrFunction;8687
8688s[ s.length ] = encodeURIComponent( key ) + "=" +8689encodeURIComponent( value == null ? "" : value );8690};8691
8692if ( a == null ) {8693return "";8694}8695
8696// If an array was passed in, assume that it is an array of form elements.8697if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {8698
8699// Serialize the form elements8700jQuery.each( a, function() {8701add( this.name, this.value );8702} );8703
8704} else {8705
8706// If traditional, encode the "old" way (the way 1.3.2 or older8707// did it), otherwise encode params recursively.8708for ( prefix in a ) {8709buildParams( prefix, a[ prefix ], traditional, add );8710}8711}8712
8713// Return the resulting serialization8714return s.join( "&" );8715};8716
8717jQuery.fn.extend( {8718serialize: function() {8719return jQuery.param( this.serializeArray() );8720},8721serializeArray: function() {8722return this.map( function() {8723
8724// Can add propHook for "elements" to filter or add form elements8725var elements = jQuery.prop( this, "elements" );8726return elements ? jQuery.makeArray( elements ) : this;8727} )8728.filter( function() {8729var type = this.type;8730
8731// Use .is( ":disabled" ) so that fieldset[disabled] works8732return this.name && !jQuery( this ).is( ":disabled" ) &&8733rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&8734( this.checked || !rcheckableType.test( type ) );8735} )8736.map( function( i, elem ) {8737var val = jQuery( this ).val();8738
8739if ( val == null ) {8740return null;8741}8742
8743if ( Array.isArray( val ) ) {8744return jQuery.map( val, function( val ) {8745return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };8746} );8747}8748
8749return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };8750} ).get();8751}8752} );8753
8754
8755var
8756r20 = /%20/g,8757rhash = /#.*$/,8758rantiCache = /([?&])_=[^&]*/,8759rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,8760
8761// #7653, #8125, #8152: local protocol detection8762rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,8763rnoContent = /^(?:GET|HEAD)$/,8764rprotocol = /^\/\//,8765
8766/* Prefilters8767* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
8768* 2) These are called:
8769* - BEFORE asking for a transport
8770* - AFTER param serialization (s.data is a string if s.processData is true)
8771* 3) key is the dataType
8772* 4) the catchall symbol "*" can be used
8773* 5) execution will start with transport dataType and THEN continue down to "*" if needed
8774*/
8775prefilters = {},8776
8777/* Transports bindings8778* 1) key is the dataType
8779* 2) the catchall symbol "*" can be used
8780* 3) selection will start with transport dataType and THEN go to "*" if needed
8781*/
8782transports = {},8783
8784// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression8785allTypes = "*/".concat( "*" ),8786
8787// Anchor tag for parsing the document origin8788originAnchor = document.createElement( "a" );8789originAnchor.href = location.href;8790
8791// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
8792function addToPrefiltersOrTransports( structure ) {8793
8794// dataTypeExpression is optional and defaults to "*"8795return function( dataTypeExpression, func ) {8796
8797if ( typeof dataTypeExpression !== "string" ) {8798func = dataTypeExpression;8799dataTypeExpression = "*";8800}8801
8802var dataType,8803i = 0,8804dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];8805
8806if ( isFunction( func ) ) {8807
8808// For each dataType in the dataTypeExpression8809while ( ( dataType = dataTypes[ i++ ] ) ) {8810
8811// Prepend if requested8812if ( dataType[ 0 ] === "+" ) {8813dataType = dataType.slice( 1 ) || "*";8814( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );8815
8816// Otherwise append8817} else {8818( structure[ dataType ] = structure[ dataType ] || [] ).push( func );8819}8820}8821}8822};8823}
8824
8825// Base inspection function for prefilters and transports
8826function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {8827
8828var inspected = {},8829seekingTransport = ( structure === transports );8830
8831function inspect( dataType ) {8832var selected;8833inspected[ dataType ] = true;8834jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {8835var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );8836if ( typeof dataTypeOrTransport === "string" &&8837!seekingTransport && !inspected[ dataTypeOrTransport ] ) {8838
8839options.dataTypes.unshift( dataTypeOrTransport );8840inspect( dataTypeOrTransport );8841return false;8842} else if ( seekingTransport ) {8843return !( selected = dataTypeOrTransport );8844}8845} );8846return selected;8847}8848
8849return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );8850}
8851
8852// A special extend for ajax options
8853// that takes "flat" options (not to be deep extended)
8854// Fixes #9887
8855function ajaxExtend( target, src ) {8856var key, deep,8857flatOptions = jQuery.ajaxSettings.flatOptions || {};8858
8859for ( key in src ) {8860if ( src[ key ] !== undefined ) {8861( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];8862}8863}8864if ( deep ) {8865jQuery.extend( true, target, deep );8866}8867
8868return target;8869}
8870
8871/* Handles responses to an ajax request:
8872* - finds the right dataType (mediates between content-type and expected dataType)
8873* - returns the corresponding response
8874*/
8875function ajaxHandleResponses( s, jqXHR, responses ) {8876
8877var ct, type, finalDataType, firstDataType,8878contents = s.contents,8879dataTypes = s.dataTypes;8880
8881// Remove auto dataType and get content-type in the process8882while ( dataTypes[ 0 ] === "*" ) {8883dataTypes.shift();8884if ( ct === undefined ) {8885ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );8886}8887}8888
8889// Check if we're dealing with a known content-type8890if ( ct ) {8891for ( type in contents ) {8892if ( contents[ type ] && contents[ type ].test( ct ) ) {8893dataTypes.unshift( type );8894break;8895}8896}8897}8898
8899// Check to see if we have a response for the expected dataType8900if ( dataTypes[ 0 ] in responses ) {8901finalDataType = dataTypes[ 0 ];8902} else {8903
8904// Try convertible dataTypes8905for ( type in responses ) {8906if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {8907finalDataType = type;8908break;8909}8910if ( !firstDataType ) {8911firstDataType = type;8912}8913}8914
8915// Or just use first one8916finalDataType = finalDataType || firstDataType;8917}8918
8919// If we found a dataType8920// We add the dataType to the list if needed8921// and return the corresponding response8922if ( finalDataType ) {8923if ( finalDataType !== dataTypes[ 0 ] ) {8924dataTypes.unshift( finalDataType );8925}8926return responses[ finalDataType ];8927}8928}
8929
8930/* Chain conversions given the request and the original response
8931* Also sets the responseXXX fields on the jqXHR instance
8932*/
8933function ajaxConvert( s, response, jqXHR, isSuccess ) {8934var conv2, current, conv, tmp, prev,8935converters = {},8936
8937// Work with a copy of dataTypes in case we need to modify it for conversion8938dataTypes = s.dataTypes.slice();8939
8940// Create converters map with lowercased keys8941if ( dataTypes[ 1 ] ) {8942for ( conv in s.converters ) {8943converters[ conv.toLowerCase() ] = s.converters[ conv ];8944}8945}8946
8947current = dataTypes.shift();8948
8949// Convert to each sequential dataType8950while ( current ) {8951
8952if ( s.responseFields[ current ] ) {8953jqXHR[ s.responseFields[ current ] ] = response;8954}8955
8956// Apply the dataFilter if provided8957if ( !prev && isSuccess && s.dataFilter ) {8958response = s.dataFilter( response, s.dataType );8959}8960
8961prev = current;8962current = dataTypes.shift();8963
8964if ( current ) {8965
8966// There's only work to do if current dataType is non-auto8967if ( current === "*" ) {8968
8969current = prev;8970
8971// Convert response if prev dataType is non-auto and differs from current8972} else if ( prev !== "*" && prev !== current ) {8973
8974// Seek a direct converter8975conv = converters[ prev + " " + current ] || converters[ "* " + current ];8976
8977// If none found, seek a pair8978if ( !conv ) {8979for ( conv2 in converters ) {8980
8981// If conv2 outputs current8982tmp = conv2.split( " " );8983if ( tmp[ 1 ] === current ) {8984
8985// If prev can be converted to accepted input8986conv = converters[ prev + " " + tmp[ 0 ] ] ||8987converters[ "* " + tmp[ 0 ] ];8988if ( conv ) {8989
8990// Condense equivalence converters8991if ( conv === true ) {8992conv = converters[ conv2 ];8993
8994// Otherwise, insert the intermediate dataType8995} else if ( converters[ conv2 ] !== true ) {8996current = tmp[ 0 ];8997dataTypes.unshift( tmp[ 1 ] );8998}8999break;9000}9001}9002}9003}9004
9005// Apply converter (if not an equivalence)9006if ( conv !== true ) {9007
9008// Unless errors are allowed to bubble, catch and return them9009if ( conv && s.throws ) {9010response = conv( response );9011} else {9012try {9013response = conv( response );9014} catch ( e ) {9015return {9016state: "parsererror",9017error: conv ? e : "No conversion from " + prev + " to " + current9018};9019}9020}9021}9022}9023}9024}9025
9026return { state: "success", data: response };9027}
9028
9029jQuery.extend( {9030
9031// Counter for holding the number of active queries9032active: 0,9033
9034// Last-Modified header cache for next request9035lastModified: {},9036etag: {},9037
9038ajaxSettings: {9039url: location.href,9040type: "GET",9041isLocal: rlocalProtocol.test( location.protocol ),9042global: true,9043processData: true,9044async: true,9045contentType: "application/x-www-form-urlencoded; charset=UTF-8",9046
9047/*9048timeout: 0,
9049data: null,
9050dataType: null,
9051username: null,
9052password: null,
9053cache: null,
9054throws: false,
9055traditional: false,
9056headers: {},
9057*/
9058
9059accepts: {9060"*": allTypes,9061text: "text/plain",9062html: "text/html",9063xml: "application/xml, text/xml",9064json: "application/json, text/javascript"9065},9066
9067contents: {9068xml: /\bxml\b/,9069html: /\bhtml/,9070json: /\bjson\b/9071},9072
9073responseFields: {9074xml: "responseXML",9075text: "responseText",9076json: "responseJSON"9077},9078
9079// Data converters9080// Keys separate source (or catchall "*") and destination types with a single space9081converters: {9082
9083// Convert anything to text9084"* text": String,9085
9086// Text to html (true = no transformation)9087"text html": true,9088
9089// Evaluate text as a json expression9090"text json": JSON.parse,9091
9092// Parse text as xml9093"text xml": jQuery.parseXML9094},9095
9096// For options that shouldn't be deep extended:9097// you can add your own custom options here if9098// and when you create one that shouldn't be9099// deep extended (see ajaxExtend)9100flatOptions: {9101url: true,9102context: true9103}9104},9105
9106// Creates a full fledged settings object into target9107// with both ajaxSettings and settings fields.9108// If target is omitted, writes into ajaxSettings.9109ajaxSetup: function( target, settings ) {9110return settings ?9111
9112// Building a settings object9113ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :9114
9115// Extending ajaxSettings9116ajaxExtend( jQuery.ajaxSettings, target );9117},9118
9119ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),9120ajaxTransport: addToPrefiltersOrTransports( transports ),9121
9122// Main method9123ajax: function( url, options ) {9124
9125// If url is an object, simulate pre-1.5 signature9126if ( typeof url === "object" ) {9127options = url;9128url = undefined;9129}9130
9131// Force options to be an object9132options = options || {};9133
9134var transport,9135
9136// URL without anti-cache param9137cacheURL,9138
9139// Response headers9140responseHeadersString,9141responseHeaders,9142
9143// timeout handle9144timeoutTimer,9145
9146// Url cleanup var9147urlAnchor,9148
9149// Request state (becomes false upon send and true upon completion)9150completed,9151
9152// To know if global events are to be dispatched9153fireGlobals,9154
9155// Loop variable9156i,9157
9158// uncached part of the url9159uncached,9160
9161// Create the final options object9162s = jQuery.ajaxSetup( {}, options ),9163
9164// Callbacks context9165callbackContext = s.context || s,9166
9167// Context for global events is callbackContext if it is a DOM node or jQuery collection9168globalEventContext = s.context &&9169( callbackContext.nodeType || callbackContext.jquery ) ?9170jQuery( callbackContext ) :9171jQuery.event,9172
9173// Deferreds9174deferred = jQuery.Deferred(),9175completeDeferred = jQuery.Callbacks( "once memory" ),9176
9177// Status-dependent callbacks9178statusCode = s.statusCode || {},9179
9180// Headers (they are sent all at once)9181requestHeaders = {},9182requestHeadersNames = {},9183
9184// Default abort message9185strAbort = "canceled",9186
9187// Fake xhr9188jqXHR = {9189readyState: 0,9190
9191// Builds headers hashtable if needed9192getResponseHeader: function( key ) {9193var match;9194if ( completed ) {9195if ( !responseHeaders ) {9196responseHeaders = {};9197while ( ( match = rheaders.exec( responseHeadersString ) ) ) {9198responseHeaders[ match[ 1 ].toLowerCase() + " " ] =9199( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )9200.concat( match[ 2 ] );9201}9202}9203match = responseHeaders[ key.toLowerCase() + " " ];9204}9205return match == null ? null : match.join( ", " );9206},9207
9208// Raw string9209getAllResponseHeaders: function() {9210return completed ? responseHeadersString : null;9211},9212
9213// Caches the header9214setRequestHeader: function( name, value ) {9215if ( completed == null ) {9216name = requestHeadersNames[ name.toLowerCase() ] =9217requestHeadersNames[ name.toLowerCase() ] || name;9218requestHeaders[ name ] = value;9219}9220return this;9221},9222
9223// Overrides response content-type header9224overrideMimeType: function( type ) {9225if ( completed == null ) {9226s.mimeType = type;9227}9228return this;9229},9230
9231// Status-dependent callbacks9232statusCode: function( map ) {9233var code;9234if ( map ) {9235if ( completed ) {9236
9237// Execute the appropriate callbacks9238jqXHR.always( map[ jqXHR.status ] );9239} else {9240
9241// Lazy-add the new callbacks in a way that preserves old ones9242for ( code in map ) {9243statusCode[ code ] = [ statusCode[ code ], map[ code ] ];9244}9245}9246}9247return this;9248},9249
9250// Cancel the request9251abort: function( statusText ) {9252var finalText = statusText || strAbort;9253if ( transport ) {9254transport.abort( finalText );9255}9256done( 0, finalText );9257return this;9258}9259};9260
9261// Attach deferreds9262deferred.promise( jqXHR );9263
9264// Add protocol if not provided (prefilters might expect it)9265// Handle falsy url in the settings object (#10093: consistency with old signature)9266// We also use the url parameter if available9267s.url = ( ( url || s.url || location.href ) + "" )9268.replace( rprotocol, location.protocol + "//" );9269
9270// Alias method option to type as per ticket #120049271s.type = options.method || options.type || s.method || s.type;9272
9273// Extract dataTypes list9274s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];9275
9276// A cross-domain request is in order when the origin doesn't match the current origin.9277if ( s.crossDomain == null ) {9278urlAnchor = document.createElement( "a" );9279
9280// Support: IE <=8 - 11, Edge 12 - 159281// IE throws exception on accessing the href property if url is malformed,9282// e.g. http://example.com:80x/9283try {9284urlAnchor.href = s.url;9285
9286// Support: IE <=8 - 11 only9287// Anchor's host property isn't correctly set when s.url is relative9288urlAnchor.href = urlAnchor.href;9289s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==9290urlAnchor.protocol + "//" + urlAnchor.host;9291} catch ( e ) {9292
9293// If there is an error parsing the URL, assume it is crossDomain,9294// it can be rejected by the transport if it is invalid9295s.crossDomain = true;9296}9297}9298
9299// Convert data if not already a string9300if ( s.data && s.processData && typeof s.data !== "string" ) {9301s.data = jQuery.param( s.data, s.traditional );9302}9303
9304// Apply prefilters9305inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );9306
9307// If request was aborted inside a prefilter, stop there9308if ( completed ) {9309return jqXHR;9310}9311
9312// We can fire global events as of now if asked to9313// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)9314fireGlobals = jQuery.event && s.global;9315
9316// Watch for a new set of requests9317if ( fireGlobals && jQuery.active++ === 0 ) {9318jQuery.event.trigger( "ajaxStart" );9319}9320
9321// Uppercase the type9322s.type = s.type.toUpperCase();9323
9324// Determine if request has content9325s.hasContent = !rnoContent.test( s.type );9326
9327// Save the URL in case we're toying with the If-Modified-Since9328// and/or If-None-Match header later on9329// Remove hash to simplify url manipulation9330cacheURL = s.url.replace( rhash, "" );9331
9332// More options handling for requests with no content9333if ( !s.hasContent ) {9334
9335// Remember the hash so we can put it back9336uncached = s.url.slice( cacheURL.length );9337
9338// If data is available and should be processed, append data to url9339if ( s.data && ( s.processData || typeof s.data === "string" ) ) {9340cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;9341
9342// #9682: remove data so that it's not used in an eventual retry9343delete s.data;9344}9345
9346// Add or update anti-cache param if needed9347if ( s.cache === false ) {9348cacheURL = cacheURL.replace( rantiCache, "$1" );9349uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;9350}9351
9352// Put hash and anti-cache on the URL that will be requested (gh-1732)9353s.url = cacheURL + uncached;9354
9355// Change '%20' to '+' if this is encoded form body content (gh-2658)9356} else if ( s.data && s.processData &&9357( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {9358s.data = s.data.replace( r20, "+" );9359}9360
9361// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.9362if ( s.ifModified ) {9363if ( jQuery.lastModified[ cacheURL ] ) {9364jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );9365}9366if ( jQuery.etag[ cacheURL ] ) {9367jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );9368}9369}9370
9371// Set the correct header, if data is being sent9372if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {9373jqXHR.setRequestHeader( "Content-Type", s.contentType );9374}9375
9376// Set the Accepts header for the server, depending on the dataType9377jqXHR.setRequestHeader(9378"Accept",9379s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?9380s.accepts[ s.dataTypes[ 0 ] ] +9381( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :9382s.accepts[ "*" ]9383);9384
9385// Check for headers option9386for ( i in s.headers ) {9387jqXHR.setRequestHeader( i, s.headers[ i ] );9388}9389
9390// Allow custom headers/mimetypes and early abort9391if ( s.beforeSend &&9392( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {9393
9394// Abort if not done already and return9395return jqXHR.abort();9396}9397
9398// Aborting is no longer a cancellation9399strAbort = "abort";9400
9401// Install callbacks on deferreds9402completeDeferred.add( s.complete );9403jqXHR.done( s.success );9404jqXHR.fail( s.error );9405
9406// Get transport9407transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );9408
9409// If no transport, we auto-abort9410if ( !transport ) {9411done( -1, "No Transport" );9412} else {9413jqXHR.readyState = 1;9414
9415// Send global event9416if ( fireGlobals ) {9417globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );9418}9419
9420// If request was aborted inside ajaxSend, stop there9421if ( completed ) {9422return jqXHR;9423}9424
9425// Timeout9426if ( s.async && s.timeout > 0 ) {9427timeoutTimer = window.setTimeout( function() {9428jqXHR.abort( "timeout" );9429}, s.timeout );9430}9431
9432try {9433completed = false;9434transport.send( requestHeaders, done );9435} catch ( e ) {9436
9437// Rethrow post-completion exceptions9438if ( completed ) {9439throw e;9440}9441
9442// Propagate others as results9443done( -1, e );9444}9445}9446
9447// Callback for when everything is done9448function done( status, nativeStatusText, responses, headers ) {9449var isSuccess, success, error, response, modified,9450statusText = nativeStatusText;9451
9452// Ignore repeat invocations9453if ( completed ) {9454return;9455}9456
9457completed = true;9458
9459// Clear timeout if it exists9460if ( timeoutTimer ) {9461window.clearTimeout( timeoutTimer );9462}9463
9464// Dereference transport for early garbage collection9465// (no matter how long the jqXHR object will be used)9466transport = undefined;9467
9468// Cache response headers9469responseHeadersString = headers || "";9470
9471// Set readyState9472jqXHR.readyState = status > 0 ? 4 : 0;9473
9474// Determine if successful9475isSuccess = status >= 200 && status < 300 || status === 304;9476
9477// Get response data9478if ( responses ) {9479response = ajaxHandleResponses( s, jqXHR, responses );9480}9481
9482// Convert no matter what (that way responseXXX fields are always set)9483response = ajaxConvert( s, response, jqXHR, isSuccess );9484
9485// If successful, handle type chaining9486if ( isSuccess ) {9487
9488// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.9489if ( s.ifModified ) {9490modified = jqXHR.getResponseHeader( "Last-Modified" );9491if ( modified ) {9492jQuery.lastModified[ cacheURL ] = modified;9493}9494modified = jqXHR.getResponseHeader( "etag" );9495if ( modified ) {9496jQuery.etag[ cacheURL ] = modified;9497}9498}9499
9500// if no content9501if ( status === 204 || s.type === "HEAD" ) {9502statusText = "nocontent";9503
9504// if not modified9505} else if ( status === 304 ) {9506statusText = "notmodified";9507
9508// If we have data, let's convert it9509} else {9510statusText = response.state;9511success = response.data;9512error = response.error;9513isSuccess = !error;9514}9515} else {9516
9517// Extract error from statusText and normalize for non-aborts9518error = statusText;9519if ( status || !statusText ) {9520statusText = "error";9521if ( status < 0 ) {9522status = 0;9523}9524}9525}9526
9527// Set data for the fake xhr object9528jqXHR.status = status;9529jqXHR.statusText = ( nativeStatusText || statusText ) + "";9530
9531// Success/Error9532if ( isSuccess ) {9533deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );9534} else {9535deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );9536}9537
9538// Status-dependent callbacks9539jqXHR.statusCode( statusCode );9540statusCode = undefined;9541
9542if ( fireGlobals ) {9543globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",9544[ jqXHR, s, isSuccess ? success : error ] );9545}9546
9547// Complete9548completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );9549
9550if ( fireGlobals ) {9551globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );9552
9553// Handle the global AJAX counter9554if ( !( --jQuery.active ) ) {9555jQuery.event.trigger( "ajaxStop" );9556}9557}9558}9559
9560return jqXHR;9561},9562
9563getJSON: function( url, data, callback ) {9564return jQuery.get( url, data, callback, "json" );9565},9566
9567getScript: function( url, callback ) {9568return jQuery.get( url, undefined, callback, "script" );9569}9570} );9571
9572jQuery.each( [ "get", "post" ], function( i, method ) {9573jQuery[ method ] = function( url, data, callback, type ) {9574
9575// Shift arguments if data argument was omitted9576if ( isFunction( data ) ) {9577type = type || callback;9578callback = data;9579data = undefined;9580}9581
9582// The url can be an options object (which then must have .url)9583return jQuery.ajax( jQuery.extend( {9584url: url,9585type: method,9586dataType: type,9587data: data,9588success: callback9589}, jQuery.isPlainObject( url ) && url ) );9590};9591} );9592
9593
9594jQuery._evalUrl = function( url, options ) {9595return jQuery.ajax( {9596url: url,9597
9598// Make this explicit, since user can override this through ajaxSetup (#11264)9599type: "GET",9600dataType: "script",9601cache: true,9602async: false,9603global: false,9604
9605// Only evaluate the response if it is successful (gh-4126)9606// dataFilter is not invoked for failure responses, so using it instead9607// of the default converter is kludgy but it works.9608converters: {9609"text script": function() {}9610},9611dataFilter: function( response ) {9612jQuery.globalEval( response, options );9613}9614} );9615};9616
9617
9618jQuery.fn.extend( {9619wrapAll: function( html ) {9620var wrap;9621
9622if ( this[ 0 ] ) {9623if ( isFunction( html ) ) {9624html = html.call( this[ 0 ] );9625}9626
9627// The elements to wrap the target around9628wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );9629
9630if ( this[ 0 ].parentNode ) {9631wrap.insertBefore( this[ 0 ] );9632}9633
9634wrap.map( function() {9635var elem = this;9636
9637while ( elem.firstElementChild ) {9638elem = elem.firstElementChild;9639}9640
9641return elem;9642} ).append( this );9643}9644
9645return this;9646},9647
9648wrapInner: function( html ) {9649if ( isFunction( html ) ) {9650return this.each( function( i ) {9651jQuery( this ).wrapInner( html.call( this, i ) );9652} );9653}9654
9655return this.each( function() {9656var self = jQuery( this ),9657contents = self.contents();9658
9659if ( contents.length ) {9660contents.wrapAll( html );9661
9662} else {9663self.append( html );9664}9665} );9666},9667
9668wrap: function( html ) {9669var htmlIsFunction = isFunction( html );9670
9671return this.each( function( i ) {9672jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );9673} );9674},9675
9676unwrap: function( selector ) {9677this.parent( selector ).not( "body" ).each( function() {9678jQuery( this ).replaceWith( this.childNodes );9679} );9680return this;9681}9682} );9683
9684
9685jQuery.expr.pseudos.hidden = function( elem ) {9686return !jQuery.expr.pseudos.visible( elem );9687};9688jQuery.expr.pseudos.visible = function( elem ) {9689return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );9690};9691
9692
9693
9694
9695jQuery.ajaxSettings.xhr = function() {9696try {9697return new window.XMLHttpRequest();9698} catch ( e ) {}9699};9700
9701var xhrSuccessStatus = {9702
9703// File protocol always yields status code 0, assume 20097040: 200,9705
9706// Support: IE <=9 only9707// #1450: sometimes IE returns 1223 when it should be 20497081223: 2049709},9710xhrSupported = jQuery.ajaxSettings.xhr();9711
9712support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );9713support.ajax = xhrSupported = !!xhrSupported;9714
9715jQuery.ajaxTransport( function( options ) {9716var callback, errorCallback;9717
9718// Cross domain only allowed if supported through XMLHttpRequest9719if ( support.cors || xhrSupported && !options.crossDomain ) {9720return {9721send: function( headers, complete ) {9722var i,9723xhr = options.xhr();9724
9725xhr.open(9726options.type,9727options.url,9728options.async,9729options.username,9730options.password9731);9732
9733// Apply custom fields if provided9734if ( options.xhrFields ) {9735for ( i in options.xhrFields ) {9736xhr[ i ] = options.xhrFields[ i ];9737}9738}9739
9740// Override mime type if needed9741if ( options.mimeType && xhr.overrideMimeType ) {9742xhr.overrideMimeType( options.mimeType );9743}9744
9745// X-Requested-With header9746// For cross-domain requests, seeing as conditions for a preflight are9747// akin to a jigsaw puzzle, we simply never set it to be sure.9748// (it can always be set on a per-request basis or even using ajaxSetup)9749// For same-domain requests, won't change header if already provided.9750if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {9751headers[ "X-Requested-With" ] = "XMLHttpRequest";9752}9753
9754// Set headers9755for ( i in headers ) {9756xhr.setRequestHeader( i, headers[ i ] );9757}9758
9759// Callback9760callback = function( type ) {9761return function() {9762if ( callback ) {9763callback = errorCallback = xhr.onload =9764xhr.onerror = xhr.onabort = xhr.ontimeout =9765xhr.onreadystatechange = null;9766
9767if ( type === "abort" ) {9768xhr.abort();9769} else if ( type === "error" ) {9770
9771// Support: IE <=9 only9772// On a manual native abort, IE9 throws9773// errors on any property access that is not readyState9774if ( typeof xhr.status !== "number" ) {9775complete( 0, "error" );9776} else {9777complete(9778
9779// File: protocol always yields status 0; see #8605, #142079780xhr.status,9781xhr.statusText9782);9783}9784} else {9785complete(9786xhrSuccessStatus[ xhr.status ] || xhr.status,9787xhr.statusText,9788
9789// Support: IE <=9 only9790// IE9 has no XHR2 but throws on binary (trac-11426)9791// For XHR2 non-text, let the caller handle it (gh-2498)9792( xhr.responseType || "text" ) !== "text" ||9793typeof xhr.responseText !== "string" ?9794{ binary: xhr.response } :9795{ text: xhr.responseText },9796xhr.getAllResponseHeaders()9797);9798}9799}9800};9801};9802
9803// Listen to events9804xhr.onload = callback();9805errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );9806
9807// Support: IE 9 only9808// Use onreadystatechange to replace onabort9809// to handle uncaught aborts9810if ( xhr.onabort !== undefined ) {9811xhr.onabort = errorCallback;9812} else {9813xhr.onreadystatechange = function() {9814
9815// Check readyState before timeout as it changes9816if ( xhr.readyState === 4 ) {9817
9818// Allow onerror to be called first,9819// but that will not handle a native abort9820// Also, save errorCallback to a variable9821// as xhr.onerror cannot be accessed9822window.setTimeout( function() {9823if ( callback ) {9824errorCallback();9825}9826} );9827}9828};9829}9830
9831// Create the abort callback9832callback = callback( "abort" );9833
9834try {9835
9836// Do send the request (this may raise an exception)9837xhr.send( options.hasContent && options.data || null );9838} catch ( e ) {9839
9840// #14683: Only rethrow if this hasn't been notified as an error yet9841if ( callback ) {9842throw e;9843}9844}9845},9846
9847abort: function() {9848if ( callback ) {9849callback();9850}9851}9852};9853}9854} );9855
9856
9857
9858
9859// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
9860jQuery.ajaxPrefilter( function( s ) {9861if ( s.crossDomain ) {9862s.contents.script = false;9863}9864} );9865
9866// Install script dataType
9867jQuery.ajaxSetup( {9868accepts: {9869script: "text/javascript, application/javascript, " +9870"application/ecmascript, application/x-ecmascript"9871},9872contents: {9873script: /\b(?:java|ecma)script\b/9874},9875converters: {9876"text script": function( text ) {9877jQuery.globalEval( text );9878return text;9879}9880}9881} );9882
9883// Handle cache's special case and crossDomain
9884jQuery.ajaxPrefilter( "script", function( s ) {9885if ( s.cache === undefined ) {9886s.cache = false;9887}9888if ( s.crossDomain ) {9889s.type = "GET";9890}9891} );9892
9893// Bind script tag hack transport
9894jQuery.ajaxTransport( "script", function( s ) {9895
9896// This transport only deals with cross domain or forced-by-attrs requests9897if ( s.crossDomain || s.scriptAttrs ) {9898var script, callback;9899return {9900send: function( _, complete ) {9901script = jQuery( "<script>" )9902.attr( s.scriptAttrs || {} )9903.prop( { charset: s.scriptCharset, src: s.url } )9904.on( "load error", callback = function( evt ) {9905script.remove();9906callback = null;9907if ( evt ) {9908complete( evt.type === "error" ? 404 : 200, evt.type );9909}9910} );9911
9912// Use native DOM manipulation to avoid our domManip AJAX trickery9913document.head.appendChild( script[ 0 ] );9914},9915abort: function() {9916if ( callback ) {9917callback();9918}9919}9920};9921}9922} );9923
9924
9925
9926
9927var oldCallbacks = [],9928rjsonp = /(=)\?(?=&|$)|\?\?/;9929
9930// Default jsonp settings
9931jQuery.ajaxSetup( {9932jsonp: "callback",9933jsonpCallback: function() {9934var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );9935this[ callback ] = true;9936return callback;9937}9938} );9939
9940// Detect, normalize options and install callbacks for jsonp requests
9941jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {9942
9943var callbackName, overwritten, responseContainer,9944jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?9945"url" :9946typeof s.data === "string" &&9947( s.contentType || "" )9948.indexOf( "application/x-www-form-urlencoded" ) === 0 &&9949rjsonp.test( s.data ) && "data"9950);9951
9952// Handle iff the expected data type is "jsonp" or we have a parameter to set9953if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {9954
9955// Get callback name, remembering preexisting value associated with it9956callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?9957s.jsonpCallback() :9958s.jsonpCallback;9959
9960// Insert callback into url or form data9961if ( jsonProp ) {9962s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );9963} else if ( s.jsonp !== false ) {9964s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;9965}9966
9967// Use data converter to retrieve json after script execution9968s.converters[ "script json" ] = function() {9969if ( !responseContainer ) {9970jQuery.error( callbackName + " was not called" );9971}9972return responseContainer[ 0 ];9973};9974
9975// Force json dataType9976s.dataTypes[ 0 ] = "json";9977
9978// Install callback9979overwritten = window[ callbackName ];9980window[ callbackName ] = function() {9981responseContainer = arguments;9982};9983
9984// Clean-up function (fires after converters)9985jqXHR.always( function() {9986
9987// If previous value didn't exist - remove it9988if ( overwritten === undefined ) {9989jQuery( window ).removeProp( callbackName );9990
9991// Otherwise restore preexisting value9992} else {9993window[ callbackName ] = overwritten;9994}9995
9996// Save back as free9997if ( s[ callbackName ] ) {9998
9999// Make sure that re-using the options doesn't screw things around10000s.jsonpCallback = originalSettings.jsonpCallback;10001
10002// Save the callback name for future use10003oldCallbacks.push( callbackName );10004}10005
10006// Call if it was a function and we have a response10007if ( responseContainer && isFunction( overwritten ) ) {10008overwritten( responseContainer[ 0 ] );10009}10010
10011responseContainer = overwritten = undefined;10012} );10013
10014// Delegate to script10015return "script";10016}10017} );10018
10019
10020
10021
10022// Support: Safari 8 only
10023// In Safari 8 documents created via document.implementation.createHTMLDocument
10024// collapse sibling forms: the second one becomes a child of the first one.
10025// Because of that, this security measure has to be disabled in Safari 8.
10026// https://bugs.webkit.org/show_bug.cgi?id=137337
10027support.createHTMLDocument = ( function() {10028var body = document.implementation.createHTMLDocument( "" ).body;10029body.innerHTML = "<form></form><form></form>";10030return body.childNodes.length === 2;10031} )();10032
10033
10034// Argument "data" should be string of html
10035// context (optional): If specified, the fragment will be created in this context,
10036// defaults to document
10037// keepScripts (optional): If true, will include scripts passed in the html string
10038jQuery.parseHTML = function( data, context, keepScripts ) {10039if ( typeof data !== "string" ) {10040return [];10041}10042if ( typeof context === "boolean" ) {10043keepScripts = context;10044context = false;10045}10046
10047var base, parsed, scripts;10048
10049if ( !context ) {10050
10051// Stop scripts or inline event handlers from being executed immediately10052// by using document.implementation10053if ( support.createHTMLDocument ) {10054context = document.implementation.createHTMLDocument( "" );10055
10056// Set the base href for the created document10057// so any parsed elements with URLs10058// are based on the document's URL (gh-2965)10059base = context.createElement( "base" );10060base.href = document.location.href;10061context.head.appendChild( base );10062} else {10063context = document;10064}10065}10066
10067parsed = rsingleTag.exec( data );10068scripts = !keepScripts && [];10069
10070// Single tag10071if ( parsed ) {10072return [ context.createElement( parsed[ 1 ] ) ];10073}10074
10075parsed = buildFragment( [ data ], context, scripts );10076
10077if ( scripts && scripts.length ) {10078jQuery( scripts ).remove();10079}10080
10081return jQuery.merge( [], parsed.childNodes );10082};10083
10084
10085/**
10086* Load a url into a page
10087*/
10088jQuery.fn.load = function( url, params, callback ) {10089var selector, type, response,10090self = this,10091off = url.indexOf( " " );10092
10093if ( off > -1 ) {10094selector = stripAndCollapse( url.slice( off ) );10095url = url.slice( 0, off );10096}10097
10098// If it's a function10099if ( isFunction( params ) ) {10100
10101// We assume that it's the callback10102callback = params;10103params = undefined;10104
10105// Otherwise, build a param string10106} else if ( params && typeof params === "object" ) {10107type = "POST";10108}10109
10110// If we have elements to modify, make the request10111if ( self.length > 0 ) {10112jQuery.ajax( {10113url: url,10114
10115// If "type" variable is undefined, then "GET" method will be used.10116// Make value of this field explicit since10117// user can override it through ajaxSetup method10118type: type || "GET",10119dataType: "html",10120data: params10121} ).done( function( responseText ) {10122
10123// Save response for use in complete callback10124response = arguments;10125
10126self.html( selector ?10127
10128// If a selector was specified, locate the right elements in a dummy div10129// Exclude scripts to avoid IE 'Permission Denied' errors10130jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :10131
10132// Otherwise use the full result10133responseText );10134
10135// If the request succeeds, this function gets "data", "status", "jqXHR"10136// but they are ignored because response was set above.10137// If it fails, this function gets "jqXHR", "status", "error"10138} ).always( callback && function( jqXHR, status ) {10139self.each( function() {10140callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );10141} );10142} );10143}10144
10145return this;10146};10147
10148
10149
10150
10151// Attach a bunch of functions for handling common AJAX events
10152jQuery.each( [10153"ajaxStart",10154"ajaxStop",10155"ajaxComplete",10156"ajaxError",10157"ajaxSuccess",10158"ajaxSend"10159], function( i, type ) {10160jQuery.fn[ type ] = function( fn ) {10161return this.on( type, fn );10162};10163} );10164
10165
10166
10167
10168jQuery.expr.pseudos.animated = function( elem ) {10169return jQuery.grep( jQuery.timers, function( fn ) {10170return elem === fn.elem;10171} ).length;10172};10173
10174
10175
10176
10177jQuery.offset = {10178setOffset: function( elem, options, i ) {10179var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,10180position = jQuery.css( elem, "position" ),10181curElem = jQuery( elem ),10182props = {};10183
10184// Set position first, in-case top/left are set even on static elem10185if ( position === "static" ) {10186elem.style.position = "relative";10187}10188
10189curOffset = curElem.offset();10190curCSSTop = jQuery.css( elem, "top" );10191curCSSLeft = jQuery.css( elem, "left" );10192calculatePosition = ( position === "absolute" || position === "fixed" ) &&10193( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;10194
10195// Need to be able to calculate position if either10196// top or left is auto and position is either absolute or fixed10197if ( calculatePosition ) {10198curPosition = curElem.position();10199curTop = curPosition.top;10200curLeft = curPosition.left;10201
10202} else {10203curTop = parseFloat( curCSSTop ) || 0;10204curLeft = parseFloat( curCSSLeft ) || 0;10205}10206
10207if ( isFunction( options ) ) {10208
10209// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)10210options = options.call( elem, i, jQuery.extend( {}, curOffset ) );10211}10212
10213if ( options.top != null ) {10214props.top = ( options.top - curOffset.top ) + curTop;10215}10216if ( options.left != null ) {10217props.left = ( options.left - curOffset.left ) + curLeft;10218}10219
10220if ( "using" in options ) {10221options.using.call( elem, props );10222
10223} else {10224curElem.css( props );10225}10226}10227};10228
10229jQuery.fn.extend( {10230
10231// offset() relates an element's border box to the document origin10232offset: function( options ) {10233
10234// Preserve chaining for setter10235if ( arguments.length ) {10236return options === undefined ?10237this :10238this.each( function( i ) {10239jQuery.offset.setOffset( this, options, i );10240} );10241}10242
10243var rect, win,10244elem = this[ 0 ];10245
10246if ( !elem ) {10247return;10248}10249
10250// Return zeros for disconnected and hidden (display: none) elements (gh-2310)10251// Support: IE <=11 only10252// Running getBoundingClientRect on a10253// disconnected node in IE throws an error10254if ( !elem.getClientRects().length ) {10255return { top: 0, left: 0 };10256}10257
10258// Get document-relative position by adding viewport scroll to viewport-relative gBCR10259rect = elem.getBoundingClientRect();10260win = elem.ownerDocument.defaultView;10261return {10262top: rect.top + win.pageYOffset,10263left: rect.left + win.pageXOffset10264};10265},10266
10267// position() relates an element's margin box to its offset parent's padding box10268// This corresponds to the behavior of CSS absolute positioning10269position: function() {10270if ( !this[ 0 ] ) {10271return;10272}10273
10274var offsetParent, offset, doc,10275elem = this[ 0 ],10276parentOffset = { top: 0, left: 0 };10277
10278// position:fixed elements are offset from the viewport, which itself always has zero offset10279if ( jQuery.css( elem, "position" ) === "fixed" ) {10280
10281// Assume position:fixed implies availability of getBoundingClientRect10282offset = elem.getBoundingClientRect();10283
10284} else {10285offset = this.offset();10286
10287// Account for the *real* offset parent, which can be the document or its root element10288// when a statically positioned element is identified10289doc = elem.ownerDocument;10290offsetParent = elem.offsetParent || doc.documentElement;10291while ( offsetParent &&10292( offsetParent === doc.body || offsetParent === doc.documentElement ) &&10293jQuery.css( offsetParent, "position" ) === "static" ) {10294
10295offsetParent = offsetParent.parentNode;10296}10297if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {10298
10299// Incorporate borders into its offset, since they are outside its content origin10300parentOffset = jQuery( offsetParent ).offset();10301parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );10302parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );10303}10304}10305
10306// Subtract parent offsets and element margins10307return {10308top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),10309left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )10310};10311},10312
10313// This method will return documentElement in the following cases:10314// 1) For the element inside the iframe without offsetParent, this method will return10315// documentElement of the parent window10316// 2) For the hidden or detached element10317// 3) For body or html element, i.e. in case of the html node - it will return itself10318//10319// but those exceptions were never presented as a real life use-cases10320// and might be considered as more preferable results.10321//10322// This logic, however, is not guaranteed and can change at any point in the future10323offsetParent: function() {10324return this.map( function() {10325var offsetParent = this.offsetParent;10326
10327while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {10328offsetParent = offsetParent.offsetParent;10329}10330
10331return offsetParent || documentElement;10332} );10333}10334} );10335
10336// Create scrollLeft and scrollTop methods
10337jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {10338var top = "pageYOffset" === prop;10339
10340jQuery.fn[ method ] = function( val ) {10341return access( this, function( elem, method, val ) {10342
10343// Coalesce documents and windows10344var win;10345if ( isWindow( elem ) ) {10346win = elem;10347} else if ( elem.nodeType === 9 ) {10348win = elem.defaultView;10349}10350
10351if ( val === undefined ) {10352return win ? win[ prop ] : elem[ method ];10353}10354
10355if ( win ) {10356win.scrollTo(10357!top ? val : win.pageXOffset,10358top ? val : win.pageYOffset10359);10360
10361} else {10362elem[ method ] = val;10363}10364}, method, val, arguments.length );10365};10366} );10367
10368// Support: Safari <=7 - 9.1, Chrome <=37 - 49
10369// Add the top/left cssHooks using jQuery.fn.position
10370// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10371// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
10372// getComputedStyle returns percent when specified for top/left/bottom/right;
10373// rather than make the css module depend on the offset module, just check for it here
10374jQuery.each( [ "top", "left" ], function( i, prop ) {10375jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,10376function( elem, computed ) {10377if ( computed ) {10378computed = curCSS( elem, prop );10379
10380// If curCSS returns percentage, fallback to offset10381return rnumnonpx.test( computed ) ?10382jQuery( elem ).position()[ prop ] + "px" :10383computed;10384}10385}10386);10387} );10388
10389
10390// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10391jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {10392jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },10393function( defaultExtra, funcName ) {10394
10395// Margin is only for outerHeight, outerWidth10396jQuery.fn[ funcName ] = function( margin, value ) {10397var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),10398extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );10399
10400return access( this, function( elem, type, value ) {10401var doc;10402
10403if ( isWindow( elem ) ) {10404
10405// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)10406return funcName.indexOf( "outer" ) === 0 ?10407elem[ "inner" + name ] :10408elem.document.documentElement[ "client" + name ];10409}10410
10411// Get document width or height10412if ( elem.nodeType === 9 ) {10413doc = elem.documentElement;10414
10415// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],10416// whichever is greatest10417return Math.max(10418elem.body[ "scroll" + name ], doc[ "scroll" + name ],10419elem.body[ "offset" + name ], doc[ "offset" + name ],10420doc[ "client" + name ]10421);10422}10423
10424return value === undefined ?10425
10426// Get width or height on the element, requesting but not forcing parseFloat10427jQuery.css( elem, type, extra ) :10428
10429// Set width or height on the element10430jQuery.style( elem, type, value, extra );10431}, type, chainable ? margin : undefined, chainable );10432};10433} );10434} );10435
10436
10437jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +10438"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +10439"change select submit keydown keypress keyup contextmenu" ).split( " " ),10440function( i, name ) {10441
10442// Handle event binding10443jQuery.fn[ name ] = function( data, fn ) {10444return arguments.length > 0 ?10445this.on( name, null, data, fn ) :10446this.trigger( name );10447};10448} );10449
10450jQuery.fn.extend( {10451hover: function( fnOver, fnOut ) {10452return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );10453}10454} );10455
10456
10457
10458
10459jQuery.fn.extend( {10460
10461bind: function( types, data, fn ) {10462return this.on( types, null, data, fn );10463},10464unbind: function( types, fn ) {10465return this.off( types, null, fn );10466},10467
10468delegate: function( selector, types, data, fn ) {10469return this.on( types, selector, data, fn );10470},10471undelegate: function( selector, types, fn ) {10472
10473// ( namespace ) or ( selector, types [, fn] )10474return arguments.length === 1 ?10475this.off( selector, "**" ) :10476this.off( types, selector || "**", fn );10477}10478} );10479
10480// Bind a function to a context, optionally partially applying any
10481// arguments.
10482// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
10483// However, it is not slated for removal any time soon
10484jQuery.proxy = function( fn, context ) {10485var tmp, args, proxy;10486
10487if ( typeof context === "string" ) {10488tmp = fn[ context ];10489context = fn;10490fn = tmp;10491}10492
10493// Quick check to determine if target is callable, in the spec10494// this throws a TypeError, but we will just return undefined.10495if ( !isFunction( fn ) ) {10496return undefined;10497}10498
10499// Simulated bind10500args = slice.call( arguments, 2 );10501proxy = function() {10502return fn.apply( context || this, args.concat( slice.call( arguments ) ) );10503};10504
10505// Set the guid of unique handler to the same of original handler, so it can be removed10506proxy.guid = fn.guid = fn.guid || jQuery.guid++;10507
10508return proxy;10509};10510
10511jQuery.holdReady = function( hold ) {10512if ( hold ) {10513jQuery.readyWait++;10514} else {10515jQuery.ready( true );10516}10517};10518jQuery.isArray = Array.isArray;10519jQuery.parseJSON = JSON.parse;10520jQuery.nodeName = nodeName;10521jQuery.isFunction = isFunction;10522jQuery.isWindow = isWindow;10523jQuery.camelCase = camelCase;10524jQuery.type = toType;10525
10526jQuery.now = Date.now;10527
10528jQuery.isNumeric = function( obj ) {10529
10530// As of jQuery 3.0, isNumeric is limited to10531// strings and numbers (primitives or objects)10532// that can be coerced to finite numbers (gh-2662)10533var type = jQuery.type( obj );10534return ( type === "number" || type === "string" ) &&10535
10536// parseFloat NaNs numeric-cast false positives ("")10537// ...but misinterprets leading-number strings, particularly hex literals ("0x...")10538// subtraction forces infinities to NaN10539!isNaN( obj - parseFloat( obj ) );10540};10541
10542
10543
10544
10545// Register as a named AMD module, since jQuery can be concatenated with other
10546// files that may use define, but not via a proper concatenation script that
10547// understands anonymous AMD modules. A named AMD is safest and most robust
10548// way to register. Lowercase jquery is used because AMD module names are
10549// derived from file names, and jQuery is normally delivered in a lowercase
10550// file name. Do this after creating the global so that if an AMD module wants
10551// to call noConflict to hide this version of jQuery, it will work.
10552
10553// Note that for maximum portability, libraries that are not jQuery should
10554// declare themselves as anonymous modules, and avoid setting a global if an
10555// AMD loader is present. jQuery is a special case. For more information, see
10556// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10557
10558if ( typeof define === "function" && define.amd ) {10559define( "jquery", [], function() {10560return jQuery;10561} );10562}
10563
10564
10565
10566
10567var
10568
10569// Map over jQuery in case of overwrite10570_jQuery = window.jQuery,10571
10572// Map over the $ in case of overwrite10573_$ = window.$;10574
10575jQuery.noConflict = function( deep ) {10576if ( window.$ === jQuery ) {10577window.$ = _$;10578}10579
10580if ( deep && window.jQuery === jQuery ) {10581window.jQuery = _jQuery;10582}10583
10584return jQuery;10585};10586
10587// Expose jQuery and $ identifiers, even in AMD
10588// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
10589// and CommonJS for browser emulators (#13566)
10590if ( !noGlobal ) {10591window.jQuery = window.$ = jQuery;10592}
10593
10594
10595
10596
10597return jQuery;10598} );10599