| 93 | Â | init: function( selector, context, rootjQuery ) { |
| 94 | Â | var match, elem, ret, doc; |
| 95 | Â | |
| 96 | Â | // Handle $(""), $(null), or $(undefined) |
| Â | 94 | |
| Â | 95 | // Start with an empty selector |
| Â | 96 | selector: "", |
| Â | 97 | |
| Â | 98 | // The default length of a jQuery object is 0 |
| Â | 99 | length: 0, |
| Â | 100 | |
| Â | 101 | toArray: function() { |
| Â | 102 | return slice.call( this ); |
| Â | 103 | }, |
| Â | 104 | |
| Â | 105 | // Get the Nth element in the matched element set OR |
| Â | 106 | // Get the whole matched element set as a clean array |
| Â | 107 | get: function( num ) { |
| Â | 108 | return num != null ? |
| Â | 109 | |
| Â | 110 | // Return just the one element from the set |
| Â | 111 | ( num < 0 ? this[ num + this.length ] : this[ num ] ) : |
| Â | 112 | |
| Â | 113 | // Return all the elements in a clean array |
| Â | 114 | slice.call( this ); |
| Â | 115 | }, |
| Â | 116 | |
| Â | 117 | // Take an array of elements and push it onto the stack |
| Â | 118 | // (returning the new matched element set) |
| Â | 119 | pushStack: function( elems ) { |
| Â | 120 | |
| Â | 121 | // Build a new jQuery matched element set |
| Â | 122 | var ret = jQuery.merge( this.constructor(), elems ); |
| Â | 123 | |
| Â | 124 | // Add the old object onto the stack (as a reference) |
| Â | 125 | ret.prevObject = this; |
| Â | 126 | ret.context = this.context; |
| Â | 127 | |
| Â | 128 | // Return the newly-formed element set |
| Â | 129 | return ret; |
| Â | 130 | }, |
| Â | 131 | |
| Â | 132 | // Execute a callback for every element in the matched set. |
| Â | 133 | // (You can seed the arguments with an array of args, but this is |
| Â | 134 | // only used internally.) |
| Â | 135 | each: function( callback, args ) { |
| Â | 136 | return jQuery.each( this, callback, args ); |
| Â | 137 | }, |
| Â | 138 | |
| Â | 139 | map: function( callback ) { |
| Â | 140 | return this.pushStack( jQuery.map(this, function( elem, i ) { |
| Â | 141 | return callback.call( elem, i, elem ); |
| Â | 142 | })); |
| Â | 143 | }, |
| Â | 144 | |
| Â | 145 | slice: function() { |
| Â | 146 | return this.pushStack( slice.apply( this, arguments ) ); |
| Â | 147 | }, |
| Â | 148 | |
| Â | 149 | first: function() { |
| Â | 150 | return this.eq( 0 ); |
| Â | 151 | }, |
| Â | 152 | |
| Â | 153 | last: function() { |
| Â | 154 | return this.eq( -1 ); |
| Â | 155 | }, |
| Â | 156 | |
| Â | 157 | eq: function( i ) { |
| Â | 158 | var len = this.length, |
| Â | 159 | j = +i + ( i < 0 ? len : 0 ); |
| Â | 160 | return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] ); |
| Â | 161 | }, |
| Â | 162 | |
| Â | 163 | end: function() { |
| Â | 164 | return this.prevObject || this.constructor(null); |
| Â | 165 | }, |
| Â | 166 | |
| Â | 167 | // For internal use only. |
| Â | 168 | // Behaves like an Array's method, not like a jQuery method. |
| Â | 169 | push: push, |
| Â | 170 | sort: deletedIds.sort, |
| Â | 171 | splice: deletedIds.splice |
| Â | 172 | }; |
| Â | 173 | |
| Â | 174 | jQuery.extend = jQuery.fn.extend = function() { |
| Â | 175 | var src, copyIsArray, copy, name, options, clone, |
| Â | 176 | target = arguments[0] || {}, |
| Â | 177 | i = 1, |
| Â | 178 | length = arguments.length, |
| Â | 179 | deep = false; |
| Â | 180 | |
| Â | 181 | // Handle a deep copy situation |
| Â | 182 | if ( typeof target === "boolean" ) { |
| Â | 183 | deep = target; |
| Â | 184 | |
| Â | 185 | // skip the boolean and the target |
| Â | 186 | target = arguments[ i ] || {}; |
| Â | 187 | i++; |
| Â | 188 | } |
| Â | 189 | |
| Â | 190 | // Handle case when target is a string or something (possible in deep copy) |
| Â | 191 | if ( typeof target !== "object" && !jQuery.isFunction(target) ) { |
| Â | 192 | target = {}; |
| Â | 193 | } |
| Â | 194 | |
| Â | 195 | // extend jQuery itself if only one argument is passed |
| Â | 196 | if ( i === length ) { |
| Â | 197 | target = this; |
| Â | 198 | i--; |
| Â | 199 | } |
| Â | 200 | |
| Â | 201 | for ( ; i < length; i++ ) { |
| Â | 202 | // Only deal with non-null/undefined values |
| Â | 203 | if ( (options = arguments[ i ]) != null ) { |
| Â | 204 | // Extend the base object |
| Â | 205 | for ( name in options ) { |
| Â | 206 | src = target[ name ]; |
| Â | 207 | copy = options[ name ]; |
| Â | 208 | |
| Â | 209 | // Prevent never-ending loop |
| Â | 210 | if ( target === copy ) { |
| Â | 211 | continue; |
| Â | 212 | } |
| Â | 213 | |
| Â | 214 | // Recurse if we're merging plain objects or arrays |
| Â | 215 | if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { |
| Â | 216 | if ( copyIsArray ) { |
| Â | 217 | copyIsArray = false; |
| Â | 218 | clone = src && jQuery.isArray(src) ? src : []; |
| Â | 219 | |
| Â | 220 | } else { |
| Â | 221 | clone = src && jQuery.isPlainObject(src) ? src : {}; |
| Â | 222 | } |
| Â | 223 | |
| Â | 224 | // Never move original objects, clone them |
| Â | 225 | target[ name ] = jQuery.extend( deep, clone, copy ); |
| Â | 226 | |
| Â | 227 | // Don't bring in undefined values |
| Â | 228 | } else if ( copy !== undefined ) { |
| Â | 229 | target[ name ] = copy; |
| Â | 230 | } |
| Â | 231 | } |
| Â | 232 | } |
| Â | 233 | } |
| Â | 234 | |
| Â | 235 | // Return the modified object |
| Â | 236 | return target; |
| Â | 237 | }; |
| Â | 238 | |
| Â | 239 | jQuery.extend({ |
| Â | 240 | // Unique for each copy of jQuery on the page |
| Â | 241 | expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), |
| Â | 242 | |
| Â | 243 | // Assume jQuery is ready without the ready module |
| Â | 244 | isReady: true, |
| Â | 245 | |
| Â | 246 | error: function( msg ) { |
| Â | 247 | throw new Error( msg ); |
| Â | 248 | }, |
| Â | 249 | |
| Â | 250 | noop: function() {}, |
| Â | 251 | |
| Â | 252 | // See test/unit/core.js for details concerning isFunction. |
| Â | 253 | // Since version 1.3, DOM methods and functions like alert |
| Â | 254 | // aren't supported. They return false on IE (#2968). |
| Â | 255 | isFunction: function( obj ) { |
| Â | 256 | return jQuery.type(obj) === "function"; |
| Â | 257 | }, |
| Â | 258 | |
| Â | 259 | isArray: Array.isArray || function( obj ) { |
| Â | 260 | return jQuery.type(obj) === "array"; |
| Â | 261 | }, |
| Â | 262 | |
| Â | 263 | isWindow: function( obj ) { |
| Â | 264 | /* jshint eqeqeq: false */ |
| Â | 265 | return obj != null && obj == obj.window; |
| Â | 266 | }, |
| Â | 267 | |
| Â | 268 | isNumeric: function( obj ) { |
| Â | 269 | // parseFloat NaNs numeric-cast false positives (null|true|false|"") |
| Â | 270 | // ...but misinterprets leading-number strings, particularly hex literals ("0x...") |
| Â | 271 | // subtraction forces infinities to NaN |
| Â | 272 | // adding 1 corrects loss of precision from parseFloat (#15100) |
| Â | 273 | return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0; |
| Â | 274 | }, |
| Â | 275 | |
| Â | 276 | isEmptyObject: function( obj ) { |
| Â | 277 | var name; |
| Â | 278 | for ( name in obj ) { |
| Â | 279 | return false; |
| Â | 280 | } |
| Â | 281 | return true; |
| Â | 282 | }, |
| Â | 283 | |
| Â | 284 | isPlainObject: function( obj ) { |
| Â | 285 | var key; |
| Â | 286 | |
| Â | 287 | // Must be an Object. |
| Â | 288 | // Because of IE, we also have to check the presence of the constructor property. |
| Â | 289 | // Make sure that DOM nodes and window objects don't pass through, as well |
| Â | 290 | if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { |
| Â | 291 | return false; |
| Â | 292 | } |
| Â | 293 | |
| Â | 294 | try { |
| Â | 295 | // Not own constructor property must be Object |
| Â | 296 | if ( obj.constructor && |
| Â | 297 | !hasOwn.call(obj, "constructor") && |
| Â | 298 | !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { |
| Â | 299 | return false; |
| Â | 300 | } |
| Â | 301 | } catch ( e ) { |
| Â | 302 | // IE8,9 Will throw exceptions on certain host objects #9897 |
| Â | 303 | return false; |
| Â | 304 | } |
| Â | 305 | |
| Â | 306 | // Support: IE<9 |
| Â | 307 | // Handle iteration over inherited properties before own properties. |
| Â | 308 | if ( support.ownLast ) { |
| Â | 309 | for ( key in obj ) { |
| Â | 310 | return hasOwn.call( obj, key ); |
| Â | 311 | } |
| Â | 312 | } |
| Â | 313 | |
| Â | 314 | // Own properties are enumerated firstly, so to speed up, |
| Â | 315 | // if last one is own, then all properties are own. |
| Â | 316 | for ( key in obj ) {} |
| Â | 317 | |
| Â | 318 | return key === undefined || hasOwn.call( obj, key ); |
| Â | 319 | }, |
| Â | 320 | |
| Â | 321 | type: function( obj ) { |
| Â | 322 | if ( obj == null ) { |
| Â | 323 | return obj + ""; |
| Â | 324 | } |
| Â | 325 | return typeof obj === "object" || typeof obj === "function" ? |
| Â | 326 | class2type[ toString.call(obj) ] || "object" : |
| Â | 327 | typeof obj; |
| Â | 328 | }, |
| Â | 329 | |
| Â | 330 | // Evaluates a script in a global context |
| Â | 331 | // Workarounds based on findings by Jim Driscoll |
| Â | 332 | // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context |
| Â | 333 | globalEval: function( data ) { |
| Â | 334 | if ( data && jQuery.trim( data ) ) { |
| Â | 335 | // We use execScript on Internet Explorer |
| Â | 336 | // We use an anonymous function so that context is window |
| Â | 337 | // rather than jQuery in Firefox |
| Â | 338 | ( window.execScript || function( data ) { |
| Â | 339 | window[ "eval" ].call( window, data ); |
| Â | 340 | } )( data ); |
| Â | 341 | } |
| Â | 342 | }, |
| Â | 343 | |
| Â | 344 | // Convert dashed to camelCase; used by the css and data modules |
| Â | 345 | // Microsoft forgot to hump their vendor prefix (#9572) |
| Â | 346 | camelCase: function( string ) { |
| Â | 347 | return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); |
| Â | 348 | }, |
| Â | 349 | |
| Â | 350 | nodeName: function( elem, name ) { |
| Â | 351 | return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); |
| Â | 352 | }, |
| Â | 353 | |
| Â | 354 | // args is for internal usage only |
| Â | 355 | each: function( obj, callback, args ) { |
| Â | 356 | var value, |
| Â | 357 | i = 0, |
| Â | 358 | length = obj.length, |
| Â | 359 | isArray = isArraylike( obj ); |
| Â | 360 | |
| Â | 361 | if ( args ) { |
| Â | 362 | if ( isArray ) { |
| Â | 363 | for ( ; i < length; i++ ) { |
| Â | 364 | value = callback.apply( obj[ i ], args ); |
| Â | 365 | |
| Â | 366 | if ( value === false ) { |
| Â | 367 | break; |
| Â | 368 | } |
| Â | 369 | } |
| Â | 370 | } else { |
| Â | 371 | for ( i in obj ) { |
| Â | 372 | value = callback.apply( obj[ i ], args ); |
| Â | 373 | |
| Â | 374 | if ( value === false ) { |
| Â | 375 | break; |
| Â | 376 | } |
| Â | 377 | } |
| Â | 378 | } |
| Â | 379 | |
| Â | 380 | // A special, fast, case for the most common use of each |
| Â | 381 | } else { |
| Â | 382 | if ( isArray ) { |
| Â | 383 | for ( ; i < length; i++ ) { |
| Â | 384 | value = callback.call( obj[ i ], i, obj[ i ] ); |
| Â | 385 | |
| Â | 386 | if ( value === false ) { |
| Â | 387 | break; |
| Â | 388 | } |
| Â | 389 | } |
| Â | 390 | } else { |
| Â | 391 | for ( i in obj ) { |
| Â | 392 | value = callback.call( obj[ i ], i, obj[ i ] ); |
| Â | 393 | |
| Â | 394 | if ( value === false ) { |
| Â | 395 | break; |
| Â | 396 | } |
| Â | 397 | } |
| Â | 398 | } |
| Â | 399 | } |
| Â | 400 | |
| Â | 401 | return obj; |
| Â | 402 | }, |
| Â | 403 | |
| Â | 404 | // Support: Android<4.1, IE<9 |
| Â | 405 | trim: function( text ) { |
| Â | 406 | return text == null ? |
| Â | 407 | "" : |
| Â | 408 | ( text + "" ).replace( rtrim, "" ); |
| Â | 409 | }, |
| Â | 410 | |
| Â | 411 | // results is for internal usage only |
| Â | 412 | makeArray: function( arr, results ) { |
| Â | 413 | var ret = results || []; |
| Â | 414 | |
| Â | 415 | if ( arr != null ) { |
| Â | 416 | if ( isArraylike( Object(arr) ) ) { |
| Â | 417 | jQuery.merge( ret, |
| Â | 418 | typeof arr === "string" ? |
| Â | 419 | [ arr ] : arr |
| Â | 420 | ); |
| Â | 421 | } else { |
| Â | 422 | push.call( ret, arr ); |
| Â | 423 | } |
| Â | 424 | } |
| Â | 425 | |
| Â | 426 | return ret; |
| Â | 427 | }, |
| Â | 428 | |
| Â | 429 | inArray: function( elem, arr, i ) { |
| Â | 430 | var len; |
| Â | 431 | |
| Â | 432 | if ( arr ) { |
| Â | 433 | if ( indexOf ) { |
| Â | 434 | return indexOf.call( arr, elem, i ); |
| Â | 435 | } |
| Â | 436 | |
| Â | 437 | len = arr.length; |
| Â | 438 | i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; |
| Â | 439 | |
| Â | 440 | for ( ; i < len; i++ ) { |
| Â | 441 | // Skip accessing in sparse arrays |
| Â | 442 | if ( i in arr && arr[ i ] === elem ) { |
| Â | 443 | return i; |
| Â | 444 | } |
| Â | 445 | } |
| Â | 446 | } |
| Â | 447 | |
| Â | 448 | return -1; |
| Â | 449 | }, |
| Â | 450 | |
| Â | 451 | merge: function( first, second ) { |
| Â | 452 | var len = +second.length, |
| Â | 453 | j = 0, |
| Â | 454 | i = first.length; |
| Â | 455 | |
| Â | 456 | while ( j < len ) { |
| Â | 457 | first[ i++ ] = second[ j++ ]; |
| Â | 458 | } |
| Â | 459 | |
| Â | 460 | // Support: IE<9 |
| Â | 461 | // Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists) |
| Â | 462 | if ( len !== len ) { |
| Â | 463 | while ( second[j] !== undefined ) { |
| Â | 464 | first[ i++ ] = second[ j++ ]; |
| Â | 465 | } |
| Â | 466 | } |
| Â | 467 | |
| Â | 468 | first.length = i; |
| Â | 469 | |
| Â | 470 | return first; |
| Â | 471 | }, |
| Â | 472 | |
| Â | 473 | grep: function( elems, callback, invert ) { |
| Â | 474 | var callbackInverse, |
| Â | 475 | matches = [], |
| Â | 476 | i = 0, |
| Â | 477 | length = elems.length, |
| Â | 478 | callbackExpect = !invert; |
| Â | 479 | |
| Â | 480 | // Go through the array, only saving the items |
| Â | 481 | // that pass the validator function |
| Â | 482 | for ( ; i < length; i++ ) { |
| Â | 483 | callbackInverse = !callback( elems[ i ], i ); |
| Â | 484 | if ( callbackInverse !== callbackExpect ) { |
| Â | 485 | matches.push( elems[ i ] ); |
| Â | 486 | } |
| Â | 487 | } |
| Â | 488 | |
| Â | 489 | return matches; |
| Â | 490 | }, |
| Â | 491 | |
| Â | 492 | // arg is for internal usage only |
| Â | 493 | map: function( elems, callback, arg ) { |
| Â | 494 | var value, |
| Â | 495 | i = 0, |
| Â | 496 | length = elems.length, |
| Â | 497 | isArray = isArraylike( elems ), |
| Â | 498 | ret = []; |
| Â | 499 | |
| Â | 500 | // Go through the array, translating each of the items to their new values |
| Â | 501 | if ( isArray ) { |
| Â | 502 | for ( ; i < length; i++ ) { |
| Â | 503 | value = callback( elems[ i ], i, arg ); |
| Â | 504 | |
| Â | 505 | if ( value != null ) { |
| Â | 506 | ret.push( value ); |
| Â | 507 | } |
| Â | 508 | } |
| Â | 509 | |
| Â | 510 | // Go through every key on the object, |
| Â | 511 | } else { |
| Â | 512 | for ( i in elems ) { |
| Â | 513 | value = callback( elems[ i ], i, arg ); |
| Â | 514 | |
| Â | 515 | if ( value != null ) { |
| Â | 516 | ret.push( value ); |
| Â | 517 | } |
| Â | 518 | } |
| Â | 519 | } |
| Â | 520 | |
| Â | 521 | // Flatten any nested arrays |
| Â | 522 | return concat.apply( [], ret ); |
| Â | 523 | }, |
| Â | 524 | |
| Â | 525 | // A global GUID counter for objects |
| Â | 526 | guid: 1, |
| Â | 527 | |
| Â | 528 | // Bind a function to a context, optionally partially applying any |
| Â | 529 | // arguments. |
| Â | 530 | proxy: function( fn, context ) { |
| Â | 531 | var args, proxy, tmp; |
| Â | 532 | |
| Â | 533 | if ( typeof context === "string" ) { |
| Â | 534 | tmp = fn[ context ]; |
| Â | 535 | context = fn; |
| Â | 536 | fn = tmp; |
| Â | 537 | } |
| Â | 538 | |
| Â | 539 | // Quick check to determine if target is callable, in the spec |
| Â | 540 | // this throws a TypeError, but we will just return undefined. |
| Â | 541 | if ( !jQuery.isFunction( fn ) ) { |
| Â | 542 | return undefined; |
| Â | 543 | } |
| Â | 544 | |
| Â | 545 | // Simulated bind |
| Â | 546 | args = slice.call( arguments, 2 ); |
| Â | 547 | proxy = function() { |
| Â | 548 | return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); |
| Â | 549 | }; |
| Â | 550 | |
| Â | 551 | // Set the guid of unique handler to the same of original handler, so it can be removed |
| Â | 552 | proxy.guid = fn.guid = fn.guid || jQuery.guid++; |
| Â | 553 | |
| Â | 554 | return proxy; |
| Â | 555 | }, |
| Â | 556 | |
| Â | 557 | now: function() { |
| Â | 558 | return +( new Date() ); |
| Â | 559 | }, |
| Â | 560 | |
| Â | 561 | // jQuery.support is not used in Core but other projects attach their |
| Â | 562 | // properties to it so it needs to exist. |
| Â | 563 | support: support |
| Â | 564 | }); |
| Â | 565 | |
| Â | 566 | // Populate the class2type map |
| Â | 567 | jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) { |
| Â | 568 | class2type[ "[object " + name + "]" ] = name.toLowerCase(); |
| Â | 569 | }); |
| Â | 570 | |
| Â | 571 | function isArraylike( obj ) { |
| Â | 572 | |
| Â | 573 | // Support: iOS 8.2 (not reproducible in simulator) |
| Â | 574 | // `in` check used to prevent JIT error (gh-2145) |
| Â | 575 | // hasOwn isn't used here due to false negatives |
| Â | 576 | // regarding Nodelist length in IE |
| Â | 577 | var length = "length" in obj && obj.length, |
| Â | 578 | type = jQuery.type( obj ); |
| Â | 579 | |
| Â | 580 | if ( type === "function" || jQuery.isWindow( obj ) ) { |
| Â | 581 | return false; |
| Â | 582 | } |
| Â | 583 | |
| Â | 584 | if ( obj.nodeType === 1 && length ) { |
| Â | 585 | return true; |
| Â | 586 | } |
| Â | 587 | |
| Â | 588 | return type === "array" || length === 0 || |
| Â | 589 | typeof length === "number" && length > 0 && ( length - 1 ) in obj; |
| Â | 590 | } |
| Â | 591 | var Sizzle = |
| Â | 592 | /*! |
| Â | 593 | * Sizzle CSS Selector Engine v2.2.0-pre |
| Â | 594 | * http://sizzlejs.com/ |
| Â | 595 | * |
| Â | 596 | * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors |
| Â | 597 | * Released under the MIT license |
| Â | 598 | * http://jquery.org/license |
| Â | 599 | * |
| Â | 600 | * Date: 2014-12-16 |
| Â | 601 | */ |
| Â | 602 | (function( window ) { |
| Â | 603 | |
| Â | 604 | var i, |
| Â | 605 | support, |
| Â | 606 | Expr, |
| Â | 607 | getText, |
| Â | 608 | isXML, |
| Â | 609 | tokenize, |
| Â | 610 | compile, |
| Â | 611 | select, |
| Â | 612 | outermostContext, |
| Â | 613 | sortInput, |
| Â | 614 | hasDuplicate, |
| Â | 615 | |
| Â | 616 | // Local document vars |
| Â | 617 | setDocument, |
| Â | 618 | document, |
| Â | 619 | docElem, |
| Â | 620 | documentIsHTML, |
| Â | 621 | rbuggyQSA, |
| Â | 622 | rbuggyMatches, |
| Â | 623 | matches, |
| Â | 624 | contains, |
| Â | 625 | |
| Â | 626 | // Instance-specific data |
| Â | 627 | expando = "sizzle" + 1 * new Date(), |
| Â | 628 | preferredDoc = window.document, |
| Â | 629 | dirruns = 0, |
| Â | 630 | done = 0, |
| Â | 631 | classCache = createCache(), |
| Â | 632 | tokenCache = createCache(), |
| Â | 633 | compilerCache = createCache(), |
| Â | 634 | sortOrder = function( a, b ) { |
| Â | 635 | if ( a === b ) { |
| Â | 636 | hasDuplicate = true; |
| Â | 637 | } |
| Â | 638 | return 0; |
| Â | 639 | }, |
| Â | 640 | |
| Â | 641 | // General-purpose constants |
| Â | 642 | MAX_NEGATIVE = 1 << 31, |
| Â | 643 | |
| Â | 644 | // Instance methods |
| Â | 645 | hasOwn = ({}).hasOwnProperty, |
| Â | 646 | arr = [], |
| Â | 647 | pop = arr.pop, |
| Â | 648 | push_native = arr.push, |
| Â | 649 | push = arr.push, |
| Â | 650 | slice = arr.slice, |
| Â | 651 | // Use a stripped-down indexOf as it's faster than native |
| Â | 652 | // http://jsperf.com/thor-indexof-vs-for/5 |
| Â | 653 | indexOf = function( list, elem ) { |
| Â | 654 | var i = 0, |
| Â | 655 | len = list.length; |
| Â | 656 | for ( ; i < len; i++ ) { |
| Â | 657 | if ( list[i] === elem ) { |
| Â | 658 | return i; |
| Â | 659 | } |
| Â | 660 | } |
| Â | 661 | return -1; |
| Â | 662 | }, |
| Â | 663 | |
| Â | 664 | booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", |
| Â | 665 | |
| Â | 666 | // Regular expressions |
| Â | 667 | |
| Â | 668 | // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace |
| Â | 669 | whitespace = "[\\x20\\t\\r\\n\\f]", |
| Â | 670 | // http://www.w3.org/TR/css3-syntax/#characters |
| Â | 671 | characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", |
| Â | 672 | |
| Â | 673 | // Loosely modeled on CSS identifier characters |
| Â | 674 | // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors |
| Â | 675 | // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier |
| Â | 676 | identifier = characterEncoding.replace( "w", "w#" ), |
| Â | 677 | |
| Â | 678 | // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors |
| Â | 679 | attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace + |
| Â | 680 | // Operator (capture 2) |
| Â | 681 | "*([*^$|!~]?=)" + whitespace + |
| Â | 682 | // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" |
| Â | 683 | "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + |
| Â | 684 | "*\\]", |
| Â | 685 | |
| Â | 686 | pseudos = ":(" + characterEncoding + ")(?:\\((" + |
| Â | 687 | // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: |
| Â | 688 | // 1. quoted (capture 3; capture 4 or capture 5) |
| Â | 689 | "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + |
| Â | 690 | // 2. simple (capture 6) |
| Â | 691 | "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + |
| Â | 692 | // 3. anything else (capture 2) |
| Â | 693 | ".*" + |
| Â | 694 | ")\\)|)", |
| Â | 695 | |
| Â | 696 | // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter |
| Â | 697 | rwhitespace = new RegExp( whitespace + "+", "g" ), |
| Â | 698 | rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), |
| Â | 699 | |
| Â | 700 | rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), |
| Â | 701 | rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), |
| Â | 702 | |
| Â | 703 | rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), |
| Â | 704 | |
| Â | 705 | rpseudo = new RegExp( pseudos ), |
| Â | 706 | ridentifier = new RegExp( "^" + identifier + "$" ), |
| Â | 707 | |
| Â | 708 | matchExpr = { |
| Â | 709 | "ID": new RegExp( "^#(" + characterEncoding + ")" ), |
| Â | 710 | "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), |
| Â | 711 | "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), |
| Â | 712 | "ATTR": new RegExp( "^" + attributes ), |
| Â | 713 | "PSEUDO": new RegExp( "^" + pseudos ), |
| Â | 714 | "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + |
| Â | 715 | "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + |
| Â | 716 | "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), |
| Â | 717 | "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), |
| Â | 718 | // For use in libraries implementing .is() |
| Â | 719 | // We use this for POS matching in `select` |
| Â | 720 | "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + |
| Â | 721 | whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) |
| Â | 722 | }, |
| Â | 723 | |
| Â | 724 | rinputs = /^(?:input|select|textarea|button)$/i, |
| Â | 725 | rheader = /^h\d$/i, |
| Â | 726 | |
| Â | 727 | rnative = /^[^{]+\{\s*\[native \w/, |
| Â | 728 | |
| Â | 729 | // Easily-parseable/retrievable ID or TAG or CLASS selectors |
| Â | 730 | rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, |
| Â | 731 | |
| Â | 732 | rsibling = /[+~]/, |
| Â | 733 | rescape = /'|\\/g, |
| Â | 734 | |
| Â | 735 | // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters |
| Â | 736 | runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), |
| Â | 737 | funescape = function( _, escaped, escapedWhitespace ) { |
| Â | 738 | var high = "0x" + escaped - 0x10000; |
| Â | 739 | // NaN means non-codepoint |
| Â | 740 | // Support: Firefox<24 |
| Â | 741 | // Workaround erroneous numeric interpretation of +"0x" |
| Â | 742 | return high !== high || escapedWhitespace ? |
| Â | 743 | escaped : |
| Â | 744 | high < 0 ? |
| Â | 745 | // BMP codepoint |
| Â | 746 | String.fromCharCode( high + 0x10000 ) : |
| Â | 747 | // Supplemental Plane codepoint (surrogate pair) |
| Â | 748 | String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); |
| Â | 749 | }, |
| Â | 750 | |
| Â | 751 | // Used for iframes |
| Â | 752 | // See setDocument() |
| Â | 753 | // Removing the function wrapper causes a "Permission Denied" |
| Â | 754 | // error in IE |
| Â | 755 | unloadHandler = function() { |
| Â | 756 | setDocument(); |
| Â | 757 | }; |
| Â | 758 | |
| Â | 759 | // Optimize for push.apply( _, NodeList ) |
| Â | 760 | try { |
| Â | 761 | push.apply( |
| Â | 762 | (arr = slice.call( preferredDoc.childNodes )), |
| Â | 763 | preferredDoc.childNodes |
| Â | 764 | ); |
| Â | 765 | // Support: Android<4.0 |
| Â | 766 | // Detect silently failing push.apply |
| Â | 767 | arr[ preferredDoc.childNodes.length ].nodeType; |
| Â | 768 | } catch ( e ) { |
| Â | 769 | push = { apply: arr.length ? |
| Â | 770 | |
| Â | 771 | // Leverage slice if possible |
| Â | 772 | function( target, els ) { |
| Â | 773 | push_native.apply( target, slice.call(els) ); |
| Â | 774 | } : |
| Â | 775 | |
| Â | 776 | // Support: IE<9 |
| Â | 777 | // Otherwise append directly |
| Â | 778 | function( target, els ) { |
| Â | 779 | var j = target.length, |
| Â | 780 | i = 0; |
| Â | 781 | // Can't trust NodeList.length |
| Â | 782 | while ( (target[j++] = els[i++]) ) {} |
| Â | 783 | target.length = j - 1; |
| Â | 784 | } |
| Â | 785 | }; |
| Â | 786 | } |
| Â | 787 | |
| Â | 788 | function Sizzle( selector, context, results, seed ) { |
| Â | 789 | var match, elem, m, nodeType, |
| Â | 790 | // QSA vars |
| Â | 791 | i, groups, old, nid, newContext, newSelector; |
| Â | 792 | |
| Â | 793 | if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { |
| Â | 794 | setDocument( context ); |
| Â | 795 | } |
| Â | 796 | |
| Â | 797 | context = context || document; |
| Â | 798 | results = results || []; |
| Â | 799 | nodeType = context.nodeType; |
| Â | 800 | |
| Â | 801 | if ( typeof selector !== "string" || !selector || |
| Â | 802 | nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { |
| Â | 803 | |
| Â | 804 | return results; |
| Â | 805 | } |
| Â | 806 | |
| Â | 807 | if ( !seed && documentIsHTML ) { |
| Â | 808 | |
| Â | 809 | // Try to shortcut find operations when possible (e.g., not under DocumentFragment) |
| Â | 810 | if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { |
| Â | 811 | // Speed-up: Sizzle("#ID") |
| Â | 812 | if ( (m = match[1]) ) { |
| Â | 813 | if ( nodeType === 9 ) { |
| Â | 814 | elem = context.getElementById( m ); |
| Â | 815 | // Check parentNode to catch when Blackberry 4.6 returns |
| Â | 816 | // nodes that are no longer in the document (jQuery #6963) |
| Â | 817 | if ( elem && elem.parentNode ) { |
| Â | 818 | // Handle the case where IE, Opera, and Webkit return items |
| Â | 819 | // by name instead of ID |
| Â | 820 | if ( elem.id === m ) { |
| Â | 821 | results.push( elem ); |
| Â | 822 | return results; |
| Â | 823 | } |
| Â | 824 | } else { |
| Â | 825 | return results; |
| Â | 826 | } |
| Â | 827 | } else { |
| Â | 828 | // Context is not a document |
| Â | 829 | if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && |
| Â | 830 | contains( context, elem ) && elem.id === m ) { |
| Â | 831 | results.push( elem ); |
| Â | 832 | return results; |
| Â | 833 | } |
| Â | 834 | } |
| Â | 835 | |
| Â | 836 | // Speed-up: Sizzle("TAG") |
| Â | 837 | } else if ( match[2] ) { |
| Â | 838 | push.apply( results, context.getElementsByTagName( selector ) ); |
| Â | 839 | return results; |
| Â | 840 | |
| Â | 841 | // Speed-up: Sizzle(".CLASS") |
| Â | 842 | } else if ( (m = match[3]) && support.getElementsByClassName ) { |
| Â | 843 | push.apply( results, context.getElementsByClassName( m ) ); |
| Â | 844 | return results; |
| Â | 845 | } |
| Â | 846 | } |
| Â | 847 | |
| Â | 848 | // QSA path |
| Â | 849 | if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { |
| Â | 850 | nid = old = expando; |
| Â | 851 | newContext = context; |
| Â | 852 | newSelector = nodeType !== 1 && selector; |
| Â | 853 | |
| Â | 854 | // qSA works strangely on Element-rooted queries |
| Â | 855 | // We can work around this by specifying an extra ID on the root |
| Â | 856 | // and working up from there (Thanks to Andrew Dupont for the technique) |
| Â | 857 | // IE 8 doesn't work on object elements |
| Â | 858 | if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { |
| Â | 859 | groups = tokenize( selector ); |
| Â | 860 | |
| Â | 861 | if ( (old = context.getAttribute("id")) ) { |
| Â | 862 | nid = old.replace( rescape, "\\$&" ); |
| Â | 863 | } else { |
| Â | 864 | context.setAttribute( "id", nid ); |
| Â | 865 | } |
| Â | 866 | nid = "[id='" + nid + "'] "; |
| Â | 867 | |
| Â | 868 | i = groups.length; |
| Â | 869 | while ( i-- ) { |
| Â | 870 | groups[i] = nid + toSelector( groups[i] ); |
| Â | 871 | } |
| Â | 872 | newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; |
| Â | 873 | newSelector = groups.join(","); |
| Â | 874 | } |
| Â | 875 | |
| Â | 876 | if ( newSelector ) { |
| Â | 877 | try { |
| Â | 878 | push.apply( results, |
| Â | 879 | newContext.querySelectorAll( newSelector ) |
| Â | 880 | ); |
| Â | 881 | return results; |
| Â | 882 | } catch(qsaError) { |
| Â | 883 | } finally { |
| Â | 884 | if ( !old ) { |
| Â | 885 | context.removeAttribute("id"); |
| Â | 886 | } |
| Â | 887 | } |
| Â | 888 | } |
| Â | 889 | } |
| Â | 890 | } |
| Â | 891 | |
| Â | 892 | // All others |
| Â | 893 | return select( selector.replace( rtrim, "$1" ), context, results, seed ); |
| Â | 894 | } |
| Â | 895 | |
| Â | 896 | /** |
| Â | 897 | * Create key-value caches of limited size |
| Â | 898 | * @returns {Function(string, Object)} Returns the Object data after storing it on itself with |
| Â | 899 | * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) |
| Â | 900 | * deleting the oldest entry |
| Â | 901 | */ |
| Â | 902 | function createCache() { |
| Â | 903 | var keys = []; |
| Â | 904 | |
| Â | 905 | function cache( key, value ) { |
| Â | 906 | // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) |
| Â | 907 | if ( keys.push( key + " " ) > Expr.cacheLength ) { |
| Â | 908 | // Only keep the most recent entries |
| Â | 909 | delete cache[ keys.shift() ]; |
| Â | 910 | } |
| Â | 911 | return (cache[ key + " " ] = value); |
| Â | 912 | } |
| Â | 913 | return cache; |
| Â | 914 | } |
| Â | 915 | |
| Â | 916 | /** |
| Â | 917 | * Mark a function for special use by Sizzle |
| Â | 918 | * @param {Function} fn The function to mark |
| Â | 919 | */ |
| Â | 920 | function markFunction( fn ) { |
| Â | 921 | fn[ expando ] = true; |
| Â | 922 | return fn; |
| Â | 923 | } |
| Â | 924 | |
| Â | 925 | /** |
| Â | 926 | * Support testing using an element |
| Â | 927 | * @param {Function} fn Passed the created div and expects a boolean result |
| Â | 928 | */ |
| Â | 929 | function assert( fn ) { |
| Â | 930 | var div = document.createElement("div"); |
| Â | 931 | |
| Â | 932 | try { |
| Â | 933 | return !!fn( div ); |
| Â | 934 | } catch (e) { |
| Â | 935 | return false; |
| Â | 936 | } finally { |
| Â | 937 | // Remove from its parent by default |
| Â | 938 | if ( div.parentNode ) { |
| Â | 939 | div.parentNode.removeChild( div ); |
| Â | 940 | } |
| Â | 941 | // release memory in IE |
| Â | 942 | div = null; |
| Â | 943 | } |
| Â | 944 | } |
| Â | 945 | |
| Â | 946 | /** |
| Â | 947 | * Adds the same handler for all of the specified attrs |
| Â | 948 | * @param {String} attrs Pipe-separated list of attributes |
| Â | 949 | * @param {Function} handler The method that will be applied |
| Â | 950 | */ |
| Â | 951 | function addHandle( attrs, handler ) { |
| Â | 952 | var arr = attrs.split("|"), |
| Â | 953 | i = attrs.length; |
| Â | 954 | |
| Â | 955 | while ( i-- ) { |
| Â | 956 | Expr.attrHandle[ arr[i] ] = handler; |
| Â | 957 | } |
| Â | 958 | } |
| Â | 959 | |
| Â | 960 | /** |
| Â | 961 | * Checks document order of two siblings |
| Â | 962 | * @param {Element} a |
| Â | 963 | * @param {Element} b |
| Â | 964 | * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b |
| Â | 965 | */ |
| Â | 966 | function siblingCheck( a, b ) { |
| Â | 967 | var cur = b && a, |
| Â | 968 | diff = cur && a.nodeType === 1 && b.nodeType === 1 && |
| Â | 969 | ( ~b.sourceIndex || MAX_NEGATIVE ) - |
| Â | 970 | ( ~a.sourceIndex || MAX_NEGATIVE ); |
| Â | 971 | |
| Â | 972 | // Use IE sourceIndex if available on both nodes |
| Â | 973 | if ( diff ) { |
| Â | 974 | return diff; |
| Â | 975 | } |
| Â | 976 | |
| Â | 977 | // Check if b follows a |
| Â | 978 | if ( cur ) { |
| Â | 979 | while ( (cur = cur.nextSibling) ) { |
| Â | 980 | if ( cur === b ) { |
| Â | 981 | return -1; |
| Â | 982 | } |
| Â | 983 | } |
| Â | 984 | } |
| Â | 985 | |
| Â | 986 | return a ? 1 : -1; |
| Â | 987 | } |
| Â | 988 | |
| Â | 989 | /** |
| Â | 990 | * Returns a function to use in pseudos for input types |
| Â | 991 | * @param {String} type |
| Â | 992 | */ |
| Â | 993 | function createInputPseudo( type ) { |
| Â | 994 | return function( elem ) { |
| Â | 995 | var name = elem.nodeName.toLowerCase(); |
| Â | 996 | return name === "input" && elem.type === type; |
| Â | 997 | }; |
| Â | 998 | } |
| Â | 999 | |
| Â | 1000 | /** |
| Â | 1001 | * Returns a function to use in pseudos for buttons |
| Â | 1002 | * @param {String} type |
| Â | 1003 | */ |
| Â | 1004 | function createButtonPseudo( type ) { |
| Â | 1005 | return function( elem ) { |
| Â | 1006 | var name = elem.nodeName.toLowerCase(); |
| Â | 1007 | return (name === "input" || name === "button") && elem.type === type; |
| Â | 1008 | }; |
| Â | 1009 | } |
| Â | 1010 | |
| Â | 1011 | /** |
| Â | 1012 | * Returns a function to use in pseudos for positionals |
| Â | 1013 | * @param {Function} fn |
| Â | 1014 | */ |
| Â | 1015 | function createPositionalPseudo( fn ) { |
| Â | 1016 | return markFunction(function( argument ) { |
| Â | 1017 | argument = +argument; |
| Â | 1018 | return markFunction(function( seed, matches ) { |
| Â | 1019 | var j, |
| Â | 1020 | matchIndexes = fn( [], seed.length, argument ), |
| Â | 1021 | i = matchIndexes.length; |
| Â | 1022 | |
| Â | 1023 | // Match elements found at the specified indexes |
| Â | 1024 | while ( i-- ) { |
| Â | 1025 | if ( seed[ (j = matchIndexes[i]) ] ) { |
| Â | 1026 | seed[j] = !(matches[j] = seed[j]); |
| Â | 1027 | } |
| Â | 1028 | } |
| Â | 1029 | }); |
| Â | 1030 | }); |
| Â | 1031 | } |
| Â | 1032 | |
| Â | 1033 | /** |
| Â | 1034 | * Checks a node for validity as a Sizzle context |
| Â | 1035 | * @param {Element|Object=} context |
| Â | 1036 | * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value |
| Â | 1037 | */ |
| Â | 1038 | function testContext( context ) { |
| Â | 1039 | return context && typeof context.getElementsByTagName !== "undefined" && context; |
| Â | 1040 | } |
| Â | 1041 | |
| Â | 1042 | // Expose support vars for convenience |
| Â | 1043 | support = Sizzle.support = {}; |
| Â | 1044 | |
| Â | 1045 | /** |
| Â | 1046 | * Detects XML nodes |
| Â | 1047 | * @param {Element|Object} elem An element or a document |
| Â | 1048 | * @returns {Boolean} True iff elem is a non-HTML XML node |
| Â | 1049 | */ |
| Â | 1050 | isXML = Sizzle.isXML = function( elem ) { |
| Â | 1051 | // documentElement is verified for cases where it doesn't yet exist |
| Â | 1052 | // (such as loading iframes in IE - #4833) |
| Â | 1053 | var documentElement = elem && (elem.ownerDocument || elem).documentElement; |
| Â | 1054 | return documentElement ? documentElement.nodeName !== "HTML" : false; |
| Â | 1055 | }; |
| Â | 1056 | |
| Â | 1057 | /** |
| Â | 1058 | * Sets document-related variables once based on the current document |
| Â | 1059 | * @param {Element|Object} [doc] An element or document object to use to set the document |
| Â | 1060 | * @returns {Object} Returns the current document |
| Â | 1061 | */ |
| Â | 1062 | setDocument = Sizzle.setDocument = function( node ) { |
| Â | 1063 | var hasCompare, parent, |
| Â | 1064 | doc = node ? node.ownerDocument || node : preferredDoc; |
| Â | 1065 | |
| Â | 1066 | // If no document and documentElement is available, return |
| Â | 1067 | if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { |
| Â | 1068 | return document; |
| Â | 1069 | } |
| Â | 1070 | |
| Â | 1071 | // Set our document |
| Â | 1072 | document = doc; |
| Â | 1073 | docElem = doc.documentElement; |
| Â | 1074 | parent = doc.defaultView; |
| Â | 1075 | |
| Â | 1076 | // Support: IE>8 |
| Â | 1077 | // If iframe document is assigned to "document" variable and if iframe has been reloaded, |
| Â | 1078 | // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936 |
| Â | 1079 | // IE6-8 do not support the defaultView property so parent will be undefined |
| Â | 1080 | if ( parent && parent !== parent.top ) { |
| Â | 1081 | // IE11 does not have attachEvent, so all must suffer |
| Â | 1082 | if ( parent.addEventListener ) { |
| Â | 1083 | parent.addEventListener( "unload", unloadHandler, false ); |
| Â | 1084 | } else if ( parent.attachEvent ) { |
| Â | 1085 | parent.attachEvent( "onunload", unloadHandler ); |
| Â | 1086 | } |
| Â | 1087 | } |
| Â | 1088 | |
| Â | 1089 | /* Support tests |
| Â | 1090 | ---------------------------------------------------------------------- */ |
| Â | 1091 | documentIsHTML = !isXML( doc ); |
| Â | 1092 | |
| Â | 1093 | /* Attributes |
| Â | 1094 | ---------------------------------------------------------------------- */ |
| Â | 1095 | |
| Â | 1096 | // Support: IE<8 |
| Â | 1097 | // Verify that getAttribute really returns attributes and not properties |
| Â | 1098 | // (excepting IE8 booleans) |
| Â | 1099 | support.attributes = assert(function( div ) { |
| Â | 1100 | div.className = "i"; |
| Â | 1101 | return !div.getAttribute("className"); |
| Â | 1102 | }); |
| Â | 1103 | |
| Â | 1104 | /* getElement(s)By* |
| Â | 1105 | ---------------------------------------------------------------------- */ |
| Â | 1106 | |
| Â | 1107 | // Check if getElementsByTagName("*") returns only elements |
| Â | 1108 | support.getElementsByTagName = assert(function( div ) { |
| Â | 1109 | div.appendChild( doc.createComment("") ); |
| Â | 1110 | return !div.getElementsByTagName("*").length; |
| Â | 1111 | }); |
| Â | 1112 | |
| Â | 1113 | // Support: IE<9 |
| Â | 1114 | support.getElementsByClassName = rnative.test( doc.getElementsByClassName ); |
| Â | 1115 | |
| Â | 1116 | // Support: IE<10 |
| Â | 1117 | // Check if getElementById returns elements by name |
| Â | 1118 | // The broken getElementById methods don't pick up programatically-set names, |
| Â | 1119 | // so use a roundabout getElementsByName test |
| Â | 1120 | support.getById = assert(function( div ) { |
| Â | 1121 | docElem.appendChild( div ).id = expando; |
| Â | 1122 | return !doc.getElementsByName || !doc.getElementsByName( expando ).length; |
| Â | 1123 | }); |
| Â | 1124 | |
| Â | 1125 | // ID find and filter |
| Â | 1126 | if ( support.getById ) { |
| Â | 1127 | Expr.find["ID"] = function( id, context ) { |
| Â | 1128 | if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { |
| Â | 1129 | var m = context.getElementById( id ); |
| Â | 1130 | // Check parentNode to catch when Blackberry 4.6 returns |
| Â | 1131 | // nodes that are no longer in the document #6963 |
| Â | 1132 | return m && m.parentNode ? [ m ] : []; |
| Â | 1133 | } |
| Â | 1134 | }; |
| Â | 1135 | Expr.filter["ID"] = function( id ) { |
| Â | 1136 | var attrId = id.replace( runescape, funescape ); |
| Â | 1137 | return function( elem ) { |
| Â | 1138 | return elem.getAttribute("id") === attrId; |
| Â | 1139 | }; |
| Â | 1140 | }; |
| Â | 1141 | } else { |
| Â | 1142 | // Support: IE6/7 |
| Â | 1143 | // getElementById is not reliable as a find shortcut |
| Â | 1144 | delete Expr.find["ID"]; |
| Â | 1145 | |
| Â | 1146 | Expr.filter["ID"] = function( id ) { |
| Â | 1147 | var attrId = id.replace( runescape, funescape ); |
| Â | 1148 | return function( elem ) { |
| Â | 1149 | var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); |
| Â | 1150 | return node && node.value === attrId; |
| Â | 1151 | }; |
| Â | 1152 | }; |
| Â | 1153 | } |
| Â | 1154 | |
| Â | 1155 | // Tag |
| Â | 1156 | Expr.find["TAG"] = support.getElementsByTagName ? |
| Â | 1157 | function( tag, context ) { |
| Â | 1158 | if ( typeof context.getElementsByTagName !== "undefined" ) { |
| Â | 1159 | return context.getElementsByTagName( tag ); |
| Â | 1160 | |
| Â | 1161 | // DocumentFragment nodes don't have gEBTN |
| Â | 1162 | } else if ( support.qsa ) { |
| Â | 1163 | return context.querySelectorAll( tag ); |
| Â | 1164 | } |
| Â | 1165 | } : |
| Â | 1166 | |
| Â | 1167 | function( tag, context ) { |
| Â | 1168 | var elem, |
| Â | 1169 | tmp = [], |
| Â | 1170 | i = 0, |
| Â | 1171 | // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too |
| Â | 1172 | results = context.getElementsByTagName( tag ); |
| Â | 1173 | |
| Â | 1174 | // Filter out possible comments |
| Â | 1175 | if ( tag === "*" ) { |
| Â | 1176 | while ( (elem = results[i++]) ) { |
| Â | 1177 | if ( elem.nodeType === 1 ) { |
| Â | 1178 | tmp.push( elem ); |
| Â | 1179 | } |
| Â | 1180 | } |
| Â | 1181 | |
| Â | 1182 | return tmp; |
| Â | 1183 | } |
| Â | 1184 | return results; |
| Â | 1185 | }; |
| Â | 1186 | |
| Â | 1187 | // Class |
| Â | 1188 | Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { |
| Â | 1189 | if ( documentIsHTML ) { |
| Â | 1190 | return context.getElementsByClassName( className ); |
| Â | 1191 | } |
| Â | 1192 | }; |
| Â | 1193 | |
| Â | 1194 | /* QSA/matchesSelector |
| Â | 1195 | ---------------------------------------------------------------------- */ |
| Â | 1196 | |
| Â | 1197 | // QSA and matchesSelector support |
| Â | 1198 | |
| Â | 1199 | // matchesSelector(:active) reports false when true (IE9/Opera 11.5) |
| Â | 1200 | rbuggyMatches = []; |
| Â | 1201 | |
| Â | 1202 | // qSa(:focus) reports false when true (Chrome 21) |
| Â | 1203 | // We allow this because of a bug in IE8/9 that throws an error |
| Â | 1204 | // whenever `document.activeElement` is accessed on an iframe |
| Â | 1205 | // So, we allow :focus to pass through QSA all the time to avoid the IE error |
| Â | 1206 | // See http://bugs.jquery.com/ticket/13378 |
| Â | 1207 | rbuggyQSA = []; |
| Â | 1208 | |
| Â | 1209 | if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) { |
| Â | 1210 | // Build QSA regex |
| Â | 1211 | // Regex strategy adopted from Diego Perini |
| Â | 1212 | assert(function( div ) { |
| Â | 1213 | // Select is set to empty string on purpose |
| Â | 1214 | // This is to test IE's treatment of not explicitly |
| Â | 1215 | // setting a boolean content attribute, |
| Â | 1216 | // since its presence should be enough |
| Â | 1217 | // http://bugs.jquery.com/ticket/12359 |
| Â | 1218 | docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" + |
| Â | 1219 | "<select id='" + expando + "-\f]' msallowcapture=''>" + |
| Â | 1220 | "<option selected=''></option></select>"; |
| Â | 1221 | |
| Â | 1222 | // Support: IE8, Opera 11-12.16 |
| Â | 1223 | // Nothing should be selected when empty strings follow ^= or $= or *= |
| Â | 1224 | // The test attribute must be unknown in Opera but "safe" for WinRT |
| Â | 1225 | // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section |
| Â | 1226 | if ( div.querySelectorAll("[msallowcapture^='']").length ) { |
| Â | 1227 | rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); |
| Â | 1228 | } |
| Â | 1229 | |
| Â | 1230 | // Support: IE8 |
| Â | 1231 | // Boolean attributes and "value" are not treated correctly |
| Â | 1232 | if ( !div.querySelectorAll("[selected]").length ) { |
| Â | 1233 | rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); |
| Â | 1234 | } |
| Â | 1235 | |
| Â | 1236 | // Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+ |
| Â | 1237 | if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) { |
| Â | 1238 | rbuggyQSA.push("~="); |
| Â | 1239 | } |
| Â | 1240 | |
| Â | 1241 | // Webkit/Opera - :checked should return selected option elements |
| Â | 1242 | // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked |
| Â | 1243 | // IE8 throws error here and will not see later tests |
| Â | 1244 | if ( !div.querySelectorAll(":checked").length ) { |
| Â | 1245 | rbuggyQSA.push(":checked"); |
| Â | 1246 | } |
| Â | 1247 | |
| Â | 1248 | // Support: Safari 8+, iOS 8+ |
| Â | 1249 | // https://bugs.webkit.org/show_bug.cgi?id=136851 |
| Â | 1250 | // In-page `selector#id sibing-combinator selector` fails |
| Â | 1251 | if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) { |
| Â | 1252 | rbuggyQSA.push(".#.+[+~]"); |
| Â | 1253 | } |
| Â | 1254 | }); |
| Â | 1255 | |
| Â | 1256 | assert(function( div ) { |
| Â | 1257 | // Support: Windows 8 Native Apps |
| Â | 1258 | // The type and name attributes are restricted during .innerHTML assignment |
| Â | 1259 | var input = doc.createElement("input"); |
| Â | 1260 | input.setAttribute( "type", "hidden" ); |
| Â | 1261 | div.appendChild( input ).setAttribute( "name", "D" ); |
| Â | 1262 | |
| Â | 1263 | // Support: IE8 |
| Â | 1264 | // Enforce case-sensitivity of name attribute |
| Â | 1265 | if ( div.querySelectorAll("[name=d]").length ) { |
| Â | 1266 | rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); |
| Â | 1267 | } |
| Â | 1268 | |
| Â | 1269 | // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) |
| Â | 1270 | // IE8 throws error here and will not see later tests |
| Â | 1271 | if ( !div.querySelectorAll(":enabled").length ) { |
| Â | 1272 | rbuggyQSA.push( ":enabled", ":disabled" ); |
| Â | 1273 | } |
| Â | 1274 | |
| Â | 1275 | // Opera 10-11 does not throw on post-comma invalid pseudos |
| Â | 1276 | div.querySelectorAll("*,:x"); |
| Â | 1277 | rbuggyQSA.push(",.*:"); |
| Â | 1278 | }); |
| Â | 1279 | } |
| Â | 1280 | |
| Â | 1281 | if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || |
| Â | 1282 | docElem.webkitMatchesSelector || |
| Â | 1283 | docElem.mozMatchesSelector || |
| Â | 1284 | docElem.oMatchesSelector || |
| Â | 1285 | docElem.msMatchesSelector) )) ) { |
| Â | 1286 | |
| Â | 1287 | assert(function( div ) { |
| Â | 1288 | // Check to see if it's possible to do matchesSelector |
| Â | 1289 | // on a disconnected node (IE 9) |
| Â | 1290 | support.disconnectedMatch = matches.call( div, "div" ); |
| Â | 1291 | |
| Â | 1292 | // This should fail with an exception |
| Â | 1293 | // Gecko does not error, returns false instead |
| Â | 1294 | matches.call( div, "[s!='']:x" ); |
| Â | 1295 | rbuggyMatches.push( "!=", pseudos ); |
| Â | 1296 | }); |
| Â | 1297 | } |
| Â | 1298 | |
| Â | 1299 | rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); |
| Â | 1300 | rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); |
| Â | 1301 | |
| Â | 1302 | /* Contains |
| Â | 1303 | ---------------------------------------------------------------------- */ |
| Â | 1304 | hasCompare = rnative.test( docElem.compareDocumentPosition ); |
| Â | 1305 | |
| Â | 1306 | // Element contains another |
| Â | 1307 | // Purposefully does not implement inclusive descendent |
| Â | 1308 | // As in, an element does not contain itself |
| Â | 1309 | contains = hasCompare || rnative.test( docElem.contains ) ? |
| Â | 1310 | function( a, b ) { |
| Â | 1311 | var adown = a.nodeType === 9 ? a.documentElement : a, |
| Â | 1312 | bup = b && b.parentNode; |
| Â | 1313 | return a === bup || !!( bup && bup.nodeType === 1 && ( |
| Â | 1314 | adown.contains ? |
| Â | 1315 | adown.contains( bup ) : |
| Â | 1316 | a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 |
| Â | 1317 | )); |
| Â | 1318 | } : |
| Â | 1319 | function( a, b ) { |
| Â | 1320 | if ( b ) { |
| Â | 1321 | while ( (b = b.parentNode) ) { |
| Â | 1322 | if ( b === a ) { |
| Â | 1323 | return true; |
| Â | 1324 | } |
| Â | 1325 | } |
| Â | 1326 | } |
| Â | 1327 | return false; |
| Â | 1328 | }; |
| Â | 1329 | |
| Â | 1330 | /* Sorting |
| Â | 1331 | ---------------------------------------------------------------------- */ |
| Â | 1332 | |
| Â | 1333 | // Document order sorting |
| Â | 1334 | sortOrder = hasCompare ? |
| Â | 1335 | function( a, b ) { |
| Â | 1336 | |
| Â | 1337 | // Flag for duplicate removal |
| Â | 1338 | if ( a === b ) { |
| Â | 1339 | hasDuplicate = true; |
| Â | 1340 | return 0; |
| Â | 1341 | } |
| Â | 1342 | |
| Â | 1343 | // Sort on method existence if only one input has compareDocumentPosition |
| Â | 1344 | var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; |
| Â | 1345 | if ( compare ) { |
| Â | 1346 | return compare; |
| Â | 1347 | } |
| Â | 1348 | |
| Â | 1349 | // Calculate position if both inputs belong to the same document |
| Â | 1350 | compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? |
| Â | 1351 | a.compareDocumentPosition( b ) : |
| Â | 1352 | |
| Â | 1353 | // Otherwise we know they are disconnected |
| Â | 1354 | 1; |
| Â | 1355 | |
| Â | 1356 | // Disconnected nodes |
| Â | 1357 | if ( compare & 1 || |
| Â | 1358 | (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { |
| Â | 1359 | |
| Â | 1360 | // Choose the first element that is related to our preferred document |
| Â | 1361 | if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { |
| Â | 1362 | return -1; |
| Â | 1363 | } |
| Â | 1364 | if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { |
| Â | 1365 | return 1; |
| Â | 1366 | } |
| Â | 1367 | |
| Â | 1368 | // Maintain original order |
| Â | 1369 | return sortInput ? |
| Â | 1370 | ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : |
| Â | 1371 | 0; |
| Â | 1372 | } |
| Â | 1373 | |
| Â | 1374 | return compare & 4 ? -1 : 1; |
| Â | 1375 | } : |
| Â | 1376 | function( a, b ) { |
| Â | 1377 | // Exit early if the nodes are identical |
| Â | 1378 | if ( a === b ) { |
| Â | 1379 | hasDuplicate = true; |
| Â | 1380 | return 0; |
| Â | 1381 | } |
| Â | 1382 | |
| Â | 1383 | var cur, |
| Â | 1384 | i = 0, |
| Â | 1385 | aup = a.parentNode, |
| Â | 1386 | bup = b.parentNode, |
| Â | 1387 | ap = [ a ], |
| Â | 1388 | bp = [ b ]; |
| Â | 1389 | |
| Â | 1390 | // Parentless nodes are either documents or disconnected |
| Â | 1391 | if ( !aup || !bup ) { |
| Â | 1392 | return a === doc ? -1 : |
| Â | 1393 | b === doc ? 1 : |
| Â | 1394 | aup ? -1 : |
| Â | 1395 | bup ? 1 : |
| Â | 1396 | sortInput ? |
| Â | 1397 | ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : |
| Â | 1398 | 0; |
| Â | 1399 | |
| Â | 1400 | // If the nodes are siblings, we can do a quick check |
| Â | 1401 | } else if ( aup === bup ) { |
| Â | 1402 | return siblingCheck( a, b ); |
| Â | 1403 | } |
| Â | 1404 | |
| Â | 1405 | // Otherwise we need full lists of their ancestors for comparison |
| Â | 1406 | cur = a; |
| Â | 1407 | while ( (cur = cur.parentNode) ) { |
| Â | 1408 | ap.unshift( cur ); |
| Â | 1409 | } |
| Â | 1410 | cur = b; |
| Â | 1411 | while ( (cur = cur.parentNode) ) { |
| Â | 1412 | bp.unshift( cur ); |
| Â | 1413 | } |
| Â | 1414 | |
| Â | 1415 | // Walk down the tree looking for a discrepancy |
| Â | 1416 | while ( ap[i] === bp[i] ) { |
| Â | 1417 | i++; |
| Â | 1418 | } |
| Â | 1419 | |
| Â | 1420 | return i ? |
| Â | 1421 | // Do a sibling check if the nodes have a common ancestor |
| Â | 1422 | siblingCheck( ap[i], bp[i] ) : |
| Â | 1423 | |
| Â | 1424 | // Otherwise nodes in our document sort first |
| Â | 1425 | ap[i] === preferredDoc ? -1 : |
| Â | 1426 | bp[i] === preferredDoc ? 1 : |
| Â | 1427 | 0; |
| Â | 1428 | }; |
| Â | 1429 | |
| Â | 1430 | return doc; |
| Â | 1431 | }; |
| Â | 1432 | |
| Â | 1433 | Sizzle.matches = function( expr, elements ) { |
| Â | 1434 | return Sizzle( expr, null, null, elements ); |
| Â | 1435 | }; |
| Â | 1436 | |
| Â | 1437 | Sizzle.matchesSelector = function( elem, expr ) { |
| Â | 1438 | // Set document vars if needed |
| Â | 1439 | if ( ( elem.ownerDocument || elem ) !== document ) { |
| Â | 1440 | setDocument( elem ); |
| Â | 1441 | } |
| Â | 1442 | |
| Â | 1443 | // Make sure that attribute selectors are quoted |
| Â | 1444 | expr = expr.replace( rattributeQuotes, "='$1']" ); |
| Â | 1445 | |
| Â | 1446 | if ( support.matchesSelector && documentIsHTML && |
| Â | 1447 | ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && |
| Â | 1448 | ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { |
| Â | 1449 | |
| Â | 1450 | try { |
| Â | 1451 | var ret = matches.call( elem, expr ); |
| Â | 1452 | |
| Â | 1453 | // IE 9's matchesSelector returns false on disconnected nodes |
| Â | 1454 | if ( ret || support.disconnectedMatch || |
| Â | 1455 | // As well, disconnected nodes are said to be in a document |
| Â | 1456 | // fragment in IE 9 |
| Â | 1457 | elem.document && elem.document.nodeType !== 11 ) { |
| Â | 1458 | return ret; |
| Â | 1459 | } |
| Â | 1460 | } catch (e) {} |
| Â | 1461 | } |
| Â | 1462 | |
| Â | 1463 | return Sizzle( expr, document, null, [ elem ] ).length > 0; |
| Â | 1464 | }; |
| Â | 1465 | |
| Â | 1466 | Sizzle.contains = function( context, elem ) { |
| Â | 1467 | // Set document vars if needed |
| Â | 1468 | if ( ( context.ownerDocument || context ) !== document ) { |
| Â | 1469 | setDocument( context ); |
| Â | 1470 | } |
| Â | 1471 | return contains( context, elem ); |
| Â | 1472 | }; |
| Â | 1473 | |
| Â | 1474 | Sizzle.attr = function( elem, name ) { |
| Â | 1475 | // Set document vars if needed |
| Â | 1476 | if ( ( elem.ownerDocument || elem ) !== document ) { |
| Â | 1477 | setDocument( elem ); |
| Â | 1478 | } |
| Â | 1479 | |
| Â | 1480 | var fn = Expr.attrHandle[ name.toLowerCase() ], |
| Â | 1481 | // Don't get fooled by Object.prototype properties (jQuery #13807) |
| Â | 1482 | val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? |
| Â | 1483 | fn( elem, name, !documentIsHTML ) : |
| Â | 1484 | undefined; |
| Â | 1485 | |
| Â | 1486 | return val !== undefined ? |
| Â | 1487 | val : |
| Â | 1488 | support.attributes || !documentIsHTML ? |
| Â | 1489 | elem.getAttribute( name ) : |
| Â | 1490 | (val = elem.getAttributeNode(name)) && val.specified ? |
| Â | 1491 | val.value : |
| Â | 1492 | null; |
| Â | 1493 | }; |
| Â | 1494 | |
| Â | 1495 | Sizzle.error = function( msg ) { |
| Â | 1496 | throw new Error( "Syntax error, unrecognized expression: " + msg ); |
| Â | 1497 | }; |
| Â | 1498 | |
| Â | 1499 | /** |
| Â | 1500 | * Document sorting and removing duplicates |
| Â | 1501 | * @param {ArrayLike} results |
| Â | 1502 | */ |
| Â | 1503 | Sizzle.uniqueSort = function( results ) { |
| Â | 1504 | var elem, |
| Â | 1505 | duplicates = [], |
| Â | 1506 | j = 0, |
| Â | 1507 | i = 0; |
| Â | 1508 | |
| Â | 1509 | // Unless we *know* we can detect duplicates, assume their presence |
| Â | 1510 | hasDuplicate = !support.detectDuplicates; |
| Â | 1511 | sortInput = !support.sortStable && results.slice( 0 ); |
| Â | 1512 | results.sort( sortOrder ); |
| Â | 1513 | |
| Â | 1514 | if ( hasDuplicate ) { |
| Â | 1515 | while ( (elem = results[i++]) ) { |
| Â | 1516 | if ( elem === results[ i ] ) { |
| Â | 1517 | j = duplicates.push( i ); |
| Â | 1518 | } |
| Â | 1519 | } |
| Â | 1520 | while ( j-- ) { |
| Â | 1521 | results.splice( duplicates[ j ], 1 ); |
| Â | 1522 | } |
| Â | 1523 | } |
| Â | 1524 | |
| Â | 1525 | // Clear input after sorting to release objects |
| Â | 1526 | // See https://github.com/jquery/sizzle/pull/225 |
| Â | 1527 | sortInput = null; |
| Â | 1528 | |
| Â | 1529 | return results; |
| Â | 1530 | }; |
| Â | 1531 | |
| Â | 1532 | /** |
| Â | 1533 | * Utility function for retrieving the text value of an array of DOM nodes |
| Â | 1534 | * @param {Array|Element} elem |
| Â | 1535 | */ |
| Â | 1536 | getText = Sizzle.getText = function( elem ) { |
| Â | 1537 | var node, |
| Â | 1538 | ret = "", |
| Â | 1539 | i = 0, |
| Â | 1540 | nodeType = elem.nodeType; |
| Â | 1541 | |
| Â | 1542 | if ( !nodeType ) { |
| Â | 1543 | // If no nodeType, this is expected to be an array |
| Â | 1544 | while ( (node = elem[i++]) ) { |
| Â | 1545 | // Do not traverse comment nodes |
| Â | 1546 | ret += getText( node ); |
| Â | 1547 | } |
| Â | 1548 | } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { |
| Â | 1549 | // Use textContent for elements |
| Â | 1550 | // innerText usage removed for consistency of new lines (jQuery #11153) |
| Â | 1551 | if ( typeof elem.textContent === "string" ) { |
| Â | 1552 | return elem.textContent; |
| Â | 1553 | } else { |
| Â | 1554 | // Traverse its children |
| Â | 1555 | for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { |
| Â | 1556 | ret += getText( elem ); |
| Â | 1557 | } |
| Â | 1558 | } |
| Â | 1559 | } else if ( nodeType === 3 || nodeType === 4 ) { |
| Â | 1560 | return elem.nodeValue; |
| Â | 1561 | } |
| Â | 1562 | // Do not include comment or processing instruction nodes |
| Â | 1563 | |
| Â | 1564 | return ret; |
| Â | 1565 | }; |
| Â | 1566 | |
| Â | 1567 | Expr = Sizzle.selectors = { |
| Â | 1568 | |
| Â | 1569 | // Can be adjusted by the user |
| Â | 1570 | cacheLength: 50, |
| Â | 1571 | |
| Â | 1572 | createPseudo: markFunction, |
| Â | 1573 | |
| Â | 1574 | match: matchExpr, |
| Â | 1575 | |
| Â | 1576 | attrHandle: {}, |
| Â | 1577 | |
| Â | 1578 | find: {}, |
| Â | 1579 | |
| Â | 1580 | relative: { |
| Â | 1581 | ">": { dir: "parentNode", first: true }, |
| Â | 1582 | " ": { dir: "parentNode" }, |
| Â | 1583 | "+": { dir: "previousSibling", first: true }, |
| Â | 1584 | "~": { dir: "previousSibling" } |
| Â | 1585 | }, |
| Â | 1586 | |
| Â | 1587 | preFilter: { |
| Â | 1588 | "ATTR": function( match ) { |
| Â | 1589 | match[1] = match[1].replace( runescape, funescape ); |
| Â | 1590 | |
| Â | 1591 | // Move the given value to match[3] whether quoted or unquoted |
| Â | 1592 | match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); |
| Â | 1593 | |
| Â | 1594 | if ( match[2] === "~=" ) { |
| Â | 1595 | match[3] = " " + match[3] + " "; |
| Â | 1596 | } |
| Â | 1597 | |
| Â | 1598 | return match.slice( 0, 4 ); |
| Â | 1599 | }, |
| Â | 1600 | |
| Â | 1601 | "CHILD": function( match ) { |
| Â | 1602 | /* matches from matchExpr["CHILD"] |
| Â | 1603 | 1 type (only|nth|...) |
| Â | 1604 | 2 what (child|of-type) |
| Â | 1605 | 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) |
| Â | 1606 | 4 xn-component of xn+y argument ([+-]?\d*n|) |
| Â | 1607 | 5 sign of xn-component |
| Â | 1608 | 6 x of xn-component |
| Â | 1609 | 7 sign of y-component |
| Â | 1610 | 8 y of y-component |
| Â | 1611 | */ |
| Â | 1612 | match[1] = match[1].toLowerCase(); |
| Â | 1613 | |
| Â | 1614 | if ( match[1].slice( 0, 3 ) === "nth" ) { |
| Â | 1615 | // nth-* requires argument |
| Â | 1616 | if ( !match[3] ) { |
| Â | 1617 | Sizzle.error( match[0] ); |
| Â | 1618 | } |
| Â | 1619 | |
| Â | 1620 | // numeric x and y parameters for Expr.filter.CHILD |
| Â | 1621 | // remember that false/true cast respectively to 0/1 |
| Â | 1622 | match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); |
| Â | 1623 | match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); |
| Â | 1624 | |
| Â | 1625 | // other types prohibit arguments |
| Â | 1626 | } else if ( match[3] ) { |
| Â | 1627 | Sizzle.error( match[0] ); |
| Â | 1628 | } |
| Â | 1629 | |
| Â | 1630 | return match; |
| Â | 1631 | }, |
| Â | 1632 | |
| Â | 1633 | "PSEUDO": function( match ) { |
| Â | 1634 | var excess, |
| Â | 1635 | unquoted = !match[6] && match[2]; |
| Â | 1636 | |
| Â | 1637 | if ( matchExpr["CHILD"].test( match[0] ) ) { |
| Â | 1638 | return null; |
| Â | 1639 | } |
| Â | 1640 | |
| Â | 1641 | // Accept quoted arguments as-is |
| Â | 1642 | if ( match[3] ) { |
| Â | 1643 | match[2] = match[4] || match[5] || ""; |
| Â | 1644 | |
| Â | 1645 | // Strip excess characters from unquoted arguments |
| Â | 1646 | } else if ( unquoted && rpseudo.test( unquoted ) && |
| Â | 1647 | // Get excess from tokenize (recursively) |
| Â | 1648 | (excess = tokenize( unquoted, true )) && |
| Â | 1649 | // advance to the next closing parenthesis |
| Â | 1650 | (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { |
| Â | 1651 | |
| Â | 1652 | // excess is a negative index |
| Â | 1653 | match[0] = match[0].slice( 0, excess ); |
| Â | 1654 | match[2] = unquoted.slice( 0, excess ); |
| Â | 1655 | } |
| Â | 1656 | |
| Â | 1657 | // Return only captures needed by the pseudo filter method (type and argument) |
| Â | 1658 | return match.slice( 0, 3 ); |
| Â | 1659 | } |
| Â | 1660 | }, |
| Â | 1661 | |
| Â | 1662 | filter: { |
| Â | 1663 | |
| Â | 1664 | "TAG": function( nodeNameSelector ) { |
| Â | 1665 | var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); |
| Â | 1666 | return nodeNameSelector === "*" ? |
| Â | 1667 | function() { return true; } : |
| Â | 1668 | function( elem ) { |
| Â | 1669 | return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; |
| Â | 1670 | }; |
| Â | 1671 | }, |
| Â | 1672 | |
| Â | 1673 | "CLASS": function( className ) { |
| Â | 1674 | var pattern = classCache[ className + " " ]; |
| Â | 1675 | |
| Â | 1676 | return pattern || |
| Â | 1677 | (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && |
| Â | 1678 | classCache( className, function( elem ) { |
| Â | 1679 | return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); |
| Â | 1680 | }); |
| Â | 1681 | }, |
| Â | 1682 | |
| Â | 1683 | "ATTR": function( name, operator, check ) { |
| Â | 1684 | return function( elem ) { |
| Â | 1685 | var result = Sizzle.attr( elem, name ); |
| Â | 1686 | |
| Â | 1687 | if ( result == null ) { |
| Â | 1688 | return operator === "!="; |
| Â | 1689 | } |
| Â | 1690 | if ( !operator ) { |
| Â | 1691 | return true; |
| Â | 1692 | } |
| Â | 1693 | |
| Â | 1694 | result += ""; |
| Â | 1695 | |
| Â | 1696 | return operator === "=" ? result === check : |
| Â | 1697 | operator === "!=" ? result !== check : |
| Â | 1698 | operator === "^=" ? check && result.indexOf( check ) === 0 : |
| Â | 1699 | operator === "*=" ? check && result.indexOf( check ) > -1 : |
| Â | 1700 | operator === "$=" ? check && result.slice( -check.length ) === check : |
| Â | 1701 | operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : |
| Â | 1702 | operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : |
| Â | 1703 | false; |
| Â | 1704 | }; |
| Â | 1705 | }, |
| Â | 1706 | |
| Â | 1707 | "CHILD": function( type, what, argument, first, last ) { |
| Â | 1708 | var simple = type.slice( 0, 3 ) !== "nth", |
| Â | 1709 | forward = type.slice( -4 ) !== "last", |
| Â | 1710 | ofType = what === "of-type"; |
| Â | 1711 | |
| Â | 1712 | return first === 1 && last === 0 ? |
| Â | 1713 | |
| Â | 1714 | // Shortcut for :nth-*(n) |
| Â | 1715 | function( elem ) { |
| Â | 1716 | return !!elem.parentNode; |
| Â | 1717 | } : |
| Â | 1718 | |
| Â | 1719 | function( elem, context, xml ) { |
| Â | 1720 | var cache, outerCache, node, diff, nodeIndex, start, |
| Â | 1721 | dir = simple !== forward ? "nextSibling" : "previousSibling", |
| Â | 1722 | parent = elem.parentNode, |
| Â | 1723 | name = ofType && elem.nodeName.toLowerCase(), |
| Â | 1724 | useCache = !xml && !ofType; |
| Â | 1725 | |
| Â | 1726 | if ( parent ) { |
| Â | 1727 | |
| Â | 1728 | // :(first|last|only)-(child|of-type) |
| Â | 1729 | if ( simple ) { |
| Â | 1730 | while ( dir ) { |
| Â | 1731 | node = elem; |
| Â | 1732 | while ( (node = node[ dir ]) ) { |
| Â | 1733 | if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { |
| Â | 1734 | return false; |
| Â | 1735 | } |
| Â | 1736 | } |
| Â | 1737 | // Reverse direction for :only-* (if we haven't yet done so) |
| Â | 1738 | start = dir = type === "only" && !start && "nextSibling"; |
| Â | 1739 | } |
| Â | 1740 | return true; |
| Â | 1741 | } |
| Â | 1742 | |
| Â | 1743 | start = [ forward ? parent.firstChild : parent.lastChild ]; |
| Â | 1744 | |
| Â | 1745 | // non-xml :nth-child(...) stores cache data on `parent` |
| Â | 1746 | if ( forward && useCache ) { |
| Â | 1747 | // Seek `elem` from a previously-cached index |
| Â | 1748 | outerCache = parent[ expando ] || (parent[ expando ] = {}); |
| Â | 1749 | cache = outerCache[ type ] || []; |
| Â | 1750 | nodeIndex = cache[0] === dirruns && cache[1]; |
| Â | 1751 | diff = cache[0] === dirruns && cache[2]; |
| Â | 1752 | node = nodeIndex && parent.childNodes[ nodeIndex ]; |
| Â | 1753 | |
| Â | 1754 | while ( (node = ++nodeIndex && node && node[ dir ] || |
| Â | 1755 | |
| Â | 1756 | // Fallback to seeking `elem` from the start |
| Â | 1757 | (diff = nodeIndex = 0) || start.pop()) ) { |
| Â | 1758 | |
| Â | 1759 | // When found, cache indexes on `parent` and break |
| Â | 1760 | if ( node.nodeType === 1 && ++diff && node === elem ) { |
| Â | 1761 | outerCache[ type ] = [ dirruns, nodeIndex, diff ]; |
| Â | 1762 | break; |
| Â | 1763 | } |
| Â | 1764 | } |
| Â | 1765 | |
| Â | 1766 | // Use previously-cached element index if available |
| Â | 1767 | } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) { |
| Â | 1768 | diff = cache[1]; |
| Â | 1769 | |
| Â | 1770 | // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...) |
| Â | 1771 | } else { |
| Â | 1772 | // Use the same loop as above to seek `elem` from the start |
| Â | 1773 | while ( (node = ++nodeIndex && node && node[ dir ] || |
| Â | 1774 | (diff = nodeIndex = 0) || start.pop()) ) { |
| Â | 1775 | |
| Â | 1776 | if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { |
| Â | 1777 | // Cache the index of each encountered element |
| Â | 1778 | if ( useCache ) { |
| Â | 1779 | (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ]; |
| Â | 1780 | } |
| Â | 1781 | |
| Â | 1782 | if ( node === elem ) { |
| Â | 1783 | break; |
| Â | 1784 | } |
| Â | 1785 | } |
| Â | 1786 | } |
| Â | 1787 | } |
| Â | 1788 | |
| Â | 1789 | // Incorporate the offset, then check against cycle size |
| Â | 1790 | diff -= last; |
| Â | 1791 | return diff === first || ( diff % first === 0 && diff / first >= 0 ); |
| Â | 1792 | } |
| Â | 1793 | }; |
| Â | 1794 | }, |
| Â | 1795 | |
| Â | 1796 | "PSEUDO": function( pseudo, argument ) { |
| Â | 1797 | // pseudo-class names are case-insensitive |
| Â | 1798 | // http://www.w3.org/TR/selectors/#pseudo-classes |
| Â | 1799 | // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters |
| Â | 1800 | // Remember that setFilters inherits from pseudos |
| Â | 1801 | var args, |
| Â | 1802 | fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || |
| Â | 1803 | Sizzle.error( "unsupported pseudo: " + pseudo ); |
| Â | 1804 | |
| Â | 1805 | // The user may use createPseudo to indicate that |
| Â | 1806 | // arguments are needed to create the filter function |
| Â | 1807 | // just as Sizzle does |
| Â | 1808 | if ( fn[ expando ] ) { |
| Â | 1809 | return fn( argument ); |
| Â | 1810 | } |
| Â | 1811 | |
| Â | 1812 | // But maintain support for old signatures |
| Â | 1813 | if ( fn.length > 1 ) { |
| Â | 1814 | args = [ pseudo, pseudo, "", argument ]; |
| Â | 1815 | return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? |
| Â | 1816 | markFunction(function( seed, matches ) { |
| Â | 1817 | var idx, |
| Â | 1818 | matched = fn( seed, argument ), |
| Â | 1819 | i = matched.length; |
| Â | 1820 | while ( i-- ) { |
| Â | 1821 | idx = indexOf( seed, matched[i] ); |
| Â | 1822 | seed[ idx ] = !( matches[ idx ] = matched[i] ); |
| Â | 1823 | } |
| Â | 1824 | }) : |
| Â | 1825 | function( elem ) { |
| Â | 1826 | return fn( elem, 0, args ); |
| Â | 1827 | }; |
| Â | 1828 | } |
| Â | 1829 | |
| Â | 1830 | return fn; |
| Â | 1831 | } |
| Â | 1832 | }, |
| Â | 1833 | |
| Â | 1834 | pseudos: { |
| Â | 1835 | // Potentially complex pseudos |
| Â | 1836 | "not": markFunction(function( selector ) { |
| Â | 1837 | // Trim the selector passed to compile |
| Â | 1838 | // to avoid treating leading and trailing |
| Â | 1839 | // spaces as combinators |
| Â | 1840 | var input = [], |
| Â | 1841 | results = [], |
| Â | 1842 | matcher = compile( selector.replace( rtrim, "$1" ) ); |
| Â | 1843 | |
| Â | 1844 | return matcher[ expando ] ? |
| Â | 1845 | markFunction(function( seed, matches, context, xml ) { |
| Â | 1846 | var elem, |
| Â | 1847 | unmatched = matcher( seed, null, xml, [] ), |
| Â | 1848 | i = seed.length; |
| Â | 1849 | |
| Â | 1850 | // Match elements unmatched by `matcher` |
| Â | 1851 | while ( i-- ) { |
| Â | 1852 | if ( (elem = unmatched[i]) ) { |
| Â | 1853 | seed[i] = !(matches[i] = elem); |
| Â | 1854 | } |
| Â | 1855 | } |
| Â | 1856 | }) : |
| Â | 1857 | function( elem, context, xml ) { |
| Â | 1858 | input[0] = elem; |
| Â | 1859 | matcher( input, null, xml, results ); |
| Â | 1860 | // Don't keep the element (issue #299) |
| Â | 1861 | input[0] = null; |
| Â | 1862 | return !results.pop(); |
| Â | 1863 | }; |
| Â | 1864 | }), |
| Â | 1865 | |
| Â | 1866 | "has": markFunction(function( selector ) { |
| Â | 1867 | return function( elem ) { |
| Â | 1868 | return Sizzle( selector, elem ).length > 0; |
| Â | 1869 | }; |
| Â | 1870 | }), |
| Â | 1871 | |
| Â | 1872 | "contains": markFunction(function( text ) { |
| Â | 1873 | text = text.replace( runescape, funescape ); |
| Â | 1874 | return function( elem ) { |
| Â | 1875 | return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; |
| Â | 1876 | }; |
| Â | 1877 | }), |
| Â | 1878 | |
| Â | 1879 | // "Whether an element is represented by a :lang() selector |
| Â | 1880 | // is based solely on the element's language value |
| Â | 1881 | // being equal to the identifier C, |
| Â | 1882 | // or beginning with the identifier C immediately followed by "-". |
| Â | 1883 | // The matching of C against the element's language value is performed case-insensitively. |
| Â | 1884 | // The identifier C does not have to be a valid language name." |
| Â | 1885 | // http://www.w3.org/TR/selectors/#lang-pseudo |
| Â | 1886 | "lang": markFunction( function( lang ) { |
| Â | 1887 | // lang value must be a valid identifier |
| Â | 1888 | if ( !ridentifier.test(lang || "") ) { |
| Â | 1889 | Sizzle.error( "unsupported lang: " + lang ); |
| Â | 1890 | } |
| Â | 1891 | lang = lang.replace( runescape, funescape ).toLowerCase(); |
| Â | 1892 | return function( elem ) { |
| Â | 1893 | var elemLang; |
| Â | 1894 | do { |
| Â | 1895 | if ( (elemLang = documentIsHTML ? |
| Â | 1896 | elem.lang : |
| Â | 1897 | elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { |
| Â | 1898 | |
| Â | 1899 | elemLang = elemLang.toLowerCase(); |
| Â | 1900 | return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; |
| Â | 1901 | } |
| Â | 1902 | } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); |
| Â | 1903 | return false; |
| Â | 1904 | }; |
| Â | 1905 | }), |
| Â | 1906 | |
| Â | 1907 | // Miscellaneous |
| Â | 1908 | "target": function( elem ) { |
| Â | 1909 | var hash = window.location && window.location.hash; |
| Â | 1910 | return hash && hash.slice( 1 ) === elem.id; |
| Â | 1911 | }, |
| Â | 1912 | |
| Â | 1913 | "root": function( elem ) { |
| Â | 1914 | return elem === docElem; |
| Â | 1915 | }, |
| Â | 1916 | |
| Â | 1917 | "focus": function( elem ) { |
| Â | 1918 | return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); |
| Â | 1919 | }, |
| Â | 1920 | |
| Â | 1921 | // Boolean properties |
| Â | 1922 | "enabled": function( elem ) { |
| Â | 1923 | return elem.disabled === false; |
| Â | 1924 | }, |
| Â | 1925 | |
| Â | 1926 | "disabled": function( elem ) { |
| Â | 1927 | return elem.disabled === true; |
| Â | 1928 | }, |
| Â | 1929 | |
| Â | 1930 | "checked": function( elem ) { |
| Â | 1931 | // In CSS3, :checked should return both checked and selected elements |
| Â | 1932 | // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked |
| Â | 1933 | var nodeName = elem.nodeName.toLowerCase(); |
| Â | 1934 | return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); |
| Â | 1935 | }, |
| Â | 1936 | |
| Â | 1937 | "selected": function( elem ) { |
| Â | 1938 | // Accessing this property makes selected-by-default |
| Â | 1939 | // options in Safari work properly |
| Â | 1940 | if ( elem.parentNode ) { |
| Â | 1941 | elem.parentNode.selectedIndex; |
| Â | 1942 | } |
| Â | 1943 | |
| Â | 1944 | return elem.selected === true; |
| Â | 1945 | }, |
| Â | 1946 | |
| Â | 1947 | // Contents |
| Â | 1948 | "empty": function( elem ) { |
| Â | 1949 | // http://www.w3.org/TR/selectors/#empty-pseudo |
| Â | 1950 | // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), |
| Â | 1951 | // but not by others (comment: 8; processing instruction: 7; etc.) |
| Â | 1952 | // nodeType < 6 works because attributes (2) do not appear as children |
| Â | 1953 | for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { |
| Â | 1954 | if ( elem.nodeType < 6 ) { |
| Â | 1955 | return false; |
| Â | 1956 | } |
| Â | 1957 | } |
| Â | 1958 | return true; |
| Â | 1959 | }, |
| Â | 1960 | |
| Â | 1961 | "parent": function( elem ) { |
| Â | 1962 | return !Expr.pseudos["empty"]( elem ); |
| Â | 1963 | }, |
| Â | 1964 | |
| Â | 1965 | // Element/input types |
| Â | 1966 | "header": function( elem ) { |
| Â | 1967 | return rheader.test( elem.nodeName ); |
| Â | 1968 | }, |
| Â | 1969 | |
| Â | 1970 | "input": function( elem ) { |
| Â | 1971 | return rinputs.test( elem.nodeName ); |
| Â | 1972 | }, |
| Â | 1973 | |
| Â | 1974 | "button": function( elem ) { |
| Â | 1975 | var name = elem.nodeName.toLowerCase(); |
| Â | 1976 | return name === "input" && elem.type === "button" || name === "button"; |
| Â | 1977 | }, |
| Â | 1978 | |
| Â | 1979 | "text": function( elem ) { |
| Â | 1980 | var attr; |
| Â | 1981 | return elem.nodeName.toLowerCase() === "input" && |
| Â | 1982 | elem.type === "text" && |
| Â | 1983 | |
| Â | 1984 | // Support: IE<8 |
| Â | 1985 | // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" |
| Â | 1986 | ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); |
| Â | 1987 | }, |
| Â | 1988 | |
| Â | 1989 | // Position-in-collection |
| Â | 1990 | "first": createPositionalPseudo(function() { |
| Â | 1991 | return [ 0 ]; |
| Â | 1992 | }), |
| Â | 1993 | |
| Â | 1994 | "last": createPositionalPseudo(function( matchIndexes, length ) { |
| Â | 1995 | return [ length - 1 ]; |
| Â | 1996 | }), |
| Â | 1997 | |
| Â | 1998 | "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { |
| Â | 1999 | return [ argument < 0 ? argument + length : argument ]; |
| Â | 2000 | }), |
| Â | 2001 | |
| Â | 2002 | "even": createPositionalPseudo(function( matchIndexes, length ) { |
| Â | 2003 | var i = 0; |
| Â | 2004 | for ( ; i < length; i += 2 ) { |
| Â | 2005 | matchIndexes.push( i ); |
| Â | 2006 | } |
| Â | 2007 | return matchIndexes; |
| Â | 2008 | }), |
| Â | 2009 | |
| Â | 2010 | "odd": createPositionalPseudo(function( matchIndexes, length ) { |
| Â | 2011 | var i = 1; |
| Â | 2012 | for ( ; i < length; i += 2 ) { |
| Â | 2013 | matchIndexes.push( i ); |
| Â | 2014 | } |
| Â | 2015 | return matchIndexes; |
| Â | 2016 | }), |
| Â | 2017 | |
| Â | 2018 | "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { |
| Â | 2019 | var i = argument < 0 ? argument + length : argument; |
| Â | 2020 | for ( ; --i >= 0; ) { |
| Â | 2021 | matchIndexes.push( i ); |
| Â | 2022 | } |
| Â | 2023 | return matchIndexes; |
| Â | 2024 | }), |
| Â | 2025 | |
| Â | 2026 | "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { |
| Â | 2027 | var i = argument < 0 ? argument + length : argument; |
| Â | 2028 | for ( ; ++i < length; ) { |
| Â | 2029 | matchIndexes.push( i ); |
| Â | 2030 | } |
| Â | 2031 | return matchIndexes; |
| Â | 2032 | }) |
| Â | 2033 | } |
| Â | 2034 | }; |
| Â | 2035 | |
| Â | 2036 | Expr.pseudos["nth"] = Expr.pseudos["eq"]; |
| Â | 2037 | |
| Â | 2038 | // Add button/input type pseudos |
| Â | 2039 | for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { |
| Â | 2040 | Expr.pseudos[ i ] = createInputPseudo( i ); |
| Â | 2041 | } |
| Â | 2042 | for ( i in { submit: true, reset: true } ) { |
| Â | 2043 | Expr.pseudos[ i ] = createButtonPseudo( i ); |
| Â | 2044 | } |
| Â | 2045 | |
| Â | 2046 | // Easy API for creating new setFilters |
| Â | 2047 | function setFilters() {} |
| Â | 2048 | setFilters.prototype = Expr.filters = Expr.pseudos; |
| Â | 2049 | Expr.setFilters = new setFilters(); |
| Â | 2050 | |
| Â | 2051 | tokenize = Sizzle.tokenize = function( selector, parseOnly ) { |
| Â | 2052 | var matched, match, tokens, type, |
| Â | 2053 | soFar, groups, preFilters, |
| Â | 2054 | cached = tokenCache[ selector + " " ]; |
| Â | 2055 | |
| Â | 2056 | if ( cached ) { |
| Â | 2057 | return parseOnly ? 0 : cached.slice( 0 ); |
| Â | 2058 | } |
| Â | 2059 | |
| Â | 2060 | soFar = selector; |
| Â | 2061 | groups = []; |
| Â | 2062 | preFilters = Expr.preFilter; |
| Â | 2063 | |
| Â | 2064 | while ( soFar ) { |
| Â | 2065 | |
| Â | 2066 | // Comma and first run |
| Â | 2067 | if ( !matched || (match = rcomma.exec( soFar )) ) { |
| Â | 2068 | if ( match ) { |
| Â | 2069 | // Don't consume trailing commas as valid |
| Â | 2070 | soFar = soFar.slice( match[0].length ) || soFar; |
| Â | 2071 | } |
| Â | 2072 | groups.push( (tokens = []) ); |
| Â | 2073 | } |
| Â | 2074 | |
| Â | 2075 | matched = false; |
| Â | 2076 | |
| Â | 2077 | // Combinators |
| Â | 2078 | if ( (match = rcombinators.exec( soFar )) ) { |
| Â | 2079 | matched = match.shift(); |
| Â | 2080 | tokens.push({ |
| Â | 2081 | value: matched, |
| Â | 2082 | // Cast descendant combinators to space |
| Â | 2083 | type: match[0].replace( rtrim, " " ) |
| Â | 2084 | }); |
| Â | 2085 | soFar = soFar.slice( matched.length ); |
| Â | 2086 | } |
| Â | 2087 | |
| Â | 2088 | // Filters |
| Â | 2089 | for ( type in Expr.filter ) { |
| Â | 2090 | if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || |
| Â | 2091 | (match = preFilters[ type ]( match ))) ) { |
| Â | 2092 | matched = match.shift(); |
| Â | 2093 | tokens.push({ |
| Â | 2094 | value: matched, |
| Â | 2095 | type: type, |
| Â | 2096 | matches: match |
| Â | 2097 | }); |
| Â | 2098 | soFar = soFar.slice( matched.length ); |
| Â | 2099 | } |
| Â | 2100 | } |
| Â | 2101 | |
| Â | 2102 | if ( !matched ) { |
| Â | 2103 | break; |
| Â | 2104 | } |
| Â | 2105 | } |
| Â | 2106 | |
| Â | 2107 | // Return the length of the invalid excess |
| Â | 2108 | // if we're just parsing |
| Â | 2109 | // Otherwise, throw an error or return tokens |
| Â | 2110 | return parseOnly ? |
| Â | 2111 | soFar.length : |
| Â | 2112 | soFar ? |
| Â | 2113 | Sizzle.error( selector ) : |
| Â | 2114 | // Cache the tokens |
| Â | 2115 | tokenCache( selector, groups ).slice( 0 ); |
| Â | 2116 | }; |
| Â | 2117 | |
| Â | 2118 | function toSelector( tokens ) { |
| Â | 2119 | var i = 0, |
| Â | 2120 | len = tokens.length, |
| Â | 2121 | selector = ""; |
| Â | 2122 | for ( ; i < len; i++ ) { |
| Â | 2123 | selector += tokens[i].value; |
| Â | 2124 | } |
| Â | 2125 | return selector; |
| Â | 2126 | } |
| Â | 2127 | |
| Â | 2128 | function addCombinator( matcher, combinator, base ) { |
| Â | 2129 | var dir = combinator.dir, |
| Â | 2130 | checkNonElements = base && dir === "parentNode", |
| Â | 2131 | doneName = done++; |
| Â | 2132 | |
| Â | 2133 | return combinator.first ? |
| Â | 2134 | // Check against closest ancestor/preceding element |
| Â | 2135 | function( elem, context, xml ) { |
| Â | 2136 | while ( (elem = elem[ dir ]) ) { |
| Â | 2137 | if ( elem.nodeType === 1 || checkNonElements ) { |
| Â | 2138 | return matcher( elem, context, xml ); |
| Â | 2139 | } |
| Â | 2140 | } |
| Â | 2141 | } : |
| Â | 2142 | |
| Â | 2143 | // Check against all ancestor/preceding elements |
| Â | 2144 | function( elem, context, xml ) { |
| Â | 2145 | var oldCache, outerCache, |
| Â | 2146 | newCache = [ dirruns, doneName ]; |
| Â | 2147 | |
| Â | 2148 | // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching |
| Â | 2149 | if ( xml ) { |
| Â | 2150 | while ( (elem = elem[ dir ]) ) { |
| Â | 2151 | if ( elem.nodeType === 1 || checkNonElements ) { |
| Â | 2152 | if ( matcher( elem, context, xml ) ) { |
| Â | 2153 | return true; |
| Â | 2154 | } |
| Â | 2155 | } |
| Â | 2156 | } |
| Â | 2157 | } else { |
| Â | 2158 | while ( (elem = elem[ dir ]) ) { |
| Â | 2159 | if ( elem.nodeType === 1 || checkNonElements ) { |
| Â | 2160 | outerCache = elem[ expando ] || (elem[ expando ] = {}); |
| Â | 2161 | if ( (oldCache = outerCache[ dir ]) && |
| Â | 2162 | oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { |
| Â | 2163 | |
| Â | 2164 | // Assign to newCache so results back-propagate to previous elements |
| Â | 2165 | return (newCache[ 2 ] = oldCache[ 2 ]); |
| Â | 2166 | } else { |
| Â | 2167 | // Reuse newcache so results back-propagate to previous elements |
| Â | 2168 | outerCache[ dir ] = newCache; |
| Â | 2169 | |
| Â | 2170 | // A match means we're done; a fail means we have to keep checking |
| Â | 2171 | if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { |
| Â | 2172 | return true; |
| Â | 2173 | } |
| Â | 2174 | } |
| Â | 2175 | } |
| Â | 2176 | } |
| Â | 2177 | } |
| Â | 2178 | }; |
| Â | 2179 | } |
| Â | 2180 | |
| Â | 2181 | function elementMatcher( matchers ) { |
| Â | 2182 | return matchers.length > 1 ? |
| Â | 2183 | function( elem, context, xml ) { |
| Â | 2184 | var i = matchers.length; |
| Â | 2185 | while ( i-- ) { |
| Â | 2186 | if ( !matchers[i]( elem, context, xml ) ) { |
| Â | 2187 | return false; |
| Â | 2188 | } |
| Â | 2189 | } |
| Â | 2190 | return true; |
| Â | 2191 | } : |
| Â | 2192 | matchers[0]; |
| Â | 2193 | } |
| Â | 2194 | |
| Â | 2195 | function multipleContexts( selector, contexts, results ) { |
| Â | 2196 | var i = 0, |
| Â | 2197 | len = contexts.length; |
| Â | 2198 | for ( ; i < len; i++ ) { |
| Â | 2199 | Sizzle( selector, contexts[i], results ); |
| Â | 2200 | } |
| Â | 2201 | return results; |
| Â | 2202 | } |
| Â | 2203 | |
| Â | 2204 | function condense( unmatched, map, filter, context, xml ) { |
| Â | 2205 | var elem, |
| Â | 2206 | newUnmatched = [], |
| Â | 2207 | i = 0, |
| Â | 2208 | len = unmatched.length, |
| Â | 2209 | mapped = map != null; |
| Â | 2210 | |
| Â | 2211 | for ( ; i < len; i++ ) { |
| Â | 2212 | if ( (elem = unmatched[i]) ) { |
| Â | 2213 | if ( !filter || filter( elem, context, xml ) ) { |
| Â | 2214 | newUnmatched.push( elem ); |
| Â | 2215 | if ( mapped ) { |
| Â | 2216 | map.push( i ); |
| Â | 2217 | } |
| Â | 2218 | } |
| Â | 2219 | } |
| Â | 2220 | } |
| Â | 2221 | |
| Â | 2222 | return newUnmatched; |
| Â | 2223 | } |
| Â | 2224 | |
| Â | 2225 | function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { |
| Â | 2226 | if ( postFilter && !postFilter[ expando ] ) { |
| Â | 2227 | postFilter = setMatcher( postFilter ); |
| Â | 2228 | } |
| Â | 2229 | if ( postFinder && !postFinder[ expando ] ) { |
| Â | 2230 | postFinder = setMatcher( postFinder, postSelector ); |
| Â | 2231 | } |
| Â | 2232 | return markFunction(function( seed, results, context, xml ) { |
| Â | 2233 | var temp, i, elem, |
| Â | 2234 | preMap = [], |
| Â | 2235 | postMap = [], |
| Â | 2236 | preexisting = results.length, |
| Â | 2237 | |
| Â | 2238 | // Get initial elements from seed or context |
| Â | 2239 | elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), |
| Â | 2240 | |
| Â | 2241 | // Prefilter to get matcher input, preserving a map for seed-results synchronization |
| Â | 2242 | matcherIn = preFilter && ( seed || !selector ) ? |
| Â | 2243 | condense( elems, preMap, preFilter, context, xml ) : |
| Â | 2244 | elems, |
| Â | 2245 | |
| Â | 2246 | matcherOut = matcher ? |
| Â | 2247 | // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, |
| Â | 2248 | postFinder || ( seed ? preFilter : preexisting || postFilter ) ? |
| Â | 2249 | |
| Â | 2250 | // ...intermediate processing is necessary |
| Â | 2251 | [] : |
| Â | 2252 | |
| Â | 2253 | // ...otherwise use results directly |
| Â | 2254 | results : |
| Â | 2255 | matcherIn; |
| Â | 2256 | |
| Â | 2257 | // Find primary matches |
| Â | 2258 | if ( matcher ) { |
| Â | 2259 | matcher( matcherIn, matcherOut, context, xml ); |
| Â | 2260 | } |
| Â | 2261 | |
| Â | 2262 | // Apply postFilter |
| Â | 2263 | if ( postFilter ) { |
| Â | 2264 | temp = condense( matcherOut, postMap ); |
| Â | 2265 | postFilter( temp, [], context, xml ); |
| Â | 2266 | |
| Â | 2267 | // Un-match failing elements by moving them back to matcherIn |
| Â | 2268 | i = temp.length; |
| Â | 2269 | while ( i-- ) { |
| Â | 2270 | if ( (elem = temp[i]) ) { |
| Â | 2271 | matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); |
| Â | 2272 | } |
| Â | 2273 | } |
| Â | 2274 | } |
| Â | 2275 | |
| Â | 2276 | if ( seed ) { |
| Â | 2277 | if ( postFinder || preFilter ) { |
| Â | 2278 | if ( postFinder ) { |
| Â | 2279 | // Get the final matcherOut by condensing this intermediate into postFinder contexts |
| Â | 2280 | temp = []; |
| Â | 2281 | i = matcherOut.length; |
| Â | 2282 | while ( i-- ) { |
| Â | 2283 | if ( (elem = matcherOut[i]) ) { |
| Â | 2284 | // Restore matcherIn since elem is not yet a final match |
| Â | 2285 | temp.push( (matcherIn[i] = elem) ); |
| Â | 2286 | } |
| Â | 2287 | } |
| Â | 2288 | postFinder( null, (matcherOut = []), temp, xml ); |
| Â | 2289 | } |
| Â | 2290 | |
| Â | 2291 | // Move matched elements from seed to results to keep them synchronized |
| Â | 2292 | i = matcherOut.length; |
| Â | 2293 | while ( i-- ) { |
| Â | 2294 | if ( (elem = matcherOut[i]) && |
| Â | 2295 | (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { |
| Â | 2296 | |
| Â | 2297 | seed[temp] = !(results[temp] = elem); |
| Â | 2298 | } |
| Â | 2299 | } |
| Â | 2300 | } |
| Â | 2301 | |
| Â | 2302 | // Add elements to results, through postFinder if defined |
| Â | 2303 | } else { |
| Â | 2304 | matcherOut = condense( |
| Â | 2305 | matcherOut === results ? |
| Â | 2306 | matcherOut.splice( preexisting, matcherOut.length ) : |
| Â | 2307 | matcherOut |
| Â | 2308 | ); |
| Â | 2309 | if ( postFinder ) { |
| Â | 2310 | postFinder( null, results, matcherOut, xml ); |
| Â | 2311 | } else { |
| Â | 2312 | push.apply( results, matcherOut ); |
| Â | 2313 | } |
| Â | 2314 | } |
| Â | 2315 | }); |
| Â | 2316 | } |
| Â | 2317 | |
| Â | 2318 | function matcherFromTokens( tokens ) { |
| Â | 2319 | var checkContext, matcher, j, |
| Â | 2320 | len = tokens.length, |
| Â | 2321 | leadingRelative = Expr.relative[ tokens[0].type ], |
| Â | 2322 | implicitRelative = leadingRelative || Expr.relative[" "], |
| Â | 2323 | i = leadingRelative ? 1 : 0, |
| Â | 2324 | |
| Â | 2325 | // The foundational matcher ensures that elements are reachable from top-level context(s) |
| Â | 2326 | matchContext = addCombinator( function( elem ) { |
| Â | 2327 | return elem === checkContext; |
| Â | 2328 | }, implicitRelative, true ), |
| Â | 2329 | matchAnyContext = addCombinator( function( elem ) { |
| Â | 2330 | return indexOf( checkContext, elem ) > -1; |
| Â | 2331 | }, implicitRelative, true ), |
| Â | 2332 | matchers = [ function( elem, context, xml ) { |
| Â | 2333 | var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( |
| Â | 2334 | (checkContext = context).nodeType ? |
| Â | 2335 | matchContext( elem, context, xml ) : |
| Â | 2336 | matchAnyContext( elem, context, xml ) ); |
| Â | 2337 | // Avoid hanging onto element (issue #299) |
| Â | 2338 | checkContext = null; |
| Â | 2339 | return ret; |
| Â | 2340 | } ]; |
| Â | 2341 | |
| Â | 2342 | for ( ; i < len; i++ ) { |
| Â | 2343 | if ( (matcher = Expr.relative[ tokens[i].type ]) ) { |
| Â | 2344 | matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; |
| Â | 2345 | } else { |
| Â | 2346 | matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); |
| Â | 2347 | |
| Â | 2348 | // Return special upon seeing a positional matcher |
| Â | 2349 | if ( matcher[ expando ] ) { |
| Â | 2350 | // Find the next relative operator (if any) for proper handling |
| Â | 2351 | j = ++i; |
| Â | 2352 | for ( ; j < len; j++ ) { |
| Â | 2353 | if ( Expr.relative[ tokens[j].type ] ) { |
| Â | 2354 | break; |
| Â | 2355 | } |
| Â | 2356 | } |
| Â | 2357 | return setMatcher( |
| Â | 2358 | i > 1 && elementMatcher( matchers ), |
| Â | 2359 | i > 1 && toSelector( |
| Â | 2360 | // If the preceding token was a descendant combinator, insert an implicit any-element `*` |
| Â | 2361 | tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) |
| Â | 2362 | ).replace( rtrim, "$1" ), |
| Â | 2363 | matcher, |
| Â | 2364 | i < j && matcherFromTokens( tokens.slice( i, j ) ), |
| Â | 2365 | j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), |
| Â | 2366 | j < len && toSelector( tokens ) |
| Â | 2367 | ); |
| Â | 2368 | } |
| Â | 2369 | matchers.push( matcher ); |
| Â | 2370 | } |
| Â | 2371 | } |
| Â | 2372 | |
| Â | 2373 | return elementMatcher( matchers ); |
| Â | 2374 | } |
| Â | 2375 | |
| Â | 2376 | function matcherFromGroupMatchers( elementMatchers, setMatchers ) { |
| Â | 2377 | var bySet = setMatchers.length > 0, |
| Â | 2378 | byElement = elementMatchers.length > 0, |
| Â | 2379 | superMatcher = function( seed, context, xml, results, outermost ) { |
| Â | 2380 | var elem, j, matcher, |
| Â | 2381 | matchedCount = 0, |
| Â | 2382 | i = "0", |
| Â | 2383 | unmatched = seed && [], |
| Â | 2384 | setMatched = [], |
| Â | 2385 | contextBackup = outermostContext, |
| Â | 2386 | // We must always have either seed elements or outermost context |
| Â | 2387 | elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), |
| Â | 2388 | // Use integer dirruns iff this is the outermost matcher |
| Â | 2389 | dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), |
| Â | 2390 | len = elems.length; |
| Â | 2391 | |
| Â | 2392 | if ( outermost ) { |
| Â | 2393 | outermostContext = context !== document && context; |
| Â | 2394 | } |
| Â | 2395 | |
| Â | 2396 | // Add elements passing elementMatchers directly to results |
| Â | 2397 | // Keep `i` a string if there are no elements so `matchedCount` will be "00" below |
| Â | 2398 | // Support: IE<9, Safari |
| Â | 2399 | // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id |
| Â | 2400 | for ( ; i !== len && (elem = elems[i]) != null; i++ ) { |
| Â | 2401 | if ( byElement && elem ) { |
| Â | 2402 | j = 0; |
| Â | 2403 | while ( (matcher = elementMatchers[j++]) ) { |
| Â | 2404 | if ( matcher( elem, context, xml ) ) { |
| Â | 2405 | results.push( elem ); |
| Â | 2406 | break; |
| Â | 2407 | } |
| Â | 2408 | } |
| Â | 2409 | if ( outermost ) { |
| Â | 2410 | dirruns = dirrunsUnique; |
| Â | 2411 | } |
| Â | 2412 | } |
| Â | 2413 | |
| Â | 2414 | // Track unmatched elements for set filters |
| Â | 2415 | if ( bySet ) { |
| Â | 2416 | // They will have gone through all possible matchers |
| Â | 2417 | if ( (elem = !matcher && elem) ) { |
| Â | 2418 | matchedCount--; |
| Â | 2419 | } |
| Â | 2420 | |
| Â | 2421 | // Lengthen the array for every element, matched or not |
| Â | 2422 | if ( seed ) { |
| Â | 2423 | unmatched.push( elem ); |
| Â | 2424 | } |
| Â | 2425 | } |
| Â | 2426 | } |
| Â | 2427 | |
| Â | 2428 | // Apply set filters to unmatched elements |
| Â | 2429 | matchedCount += i; |
| Â | 2430 | if ( bySet && i !== matchedCount ) { |
| Â | 2431 | j = 0; |
| Â | 2432 | while ( (matcher = setMatchers[j++]) ) { |
| Â | 2433 | matcher( unmatched, setMatched, context, xml ); |
| Â | 2434 | } |
| Â | 2435 | |
| Â | 2436 | if ( seed ) { |
| Â | 2437 | // Reintegrate element matches to eliminate the need for sorting |
| Â | 2438 | if ( matchedCount > 0 ) { |
| Â | 2439 | while ( i-- ) { |
| Â | 2440 | if ( !(unmatched[i] || setMatched[i]) ) { |
| Â | 2441 | setMatched[i] = pop.call( results ); |
| Â | 2442 | } |
| Â | 2443 | } |
| Â | 2444 | } |
| Â | 2445 | |
| Â | 2446 | // Discard index placeholder values to get only actual matches |
| Â | 2447 | setMatched = condense( setMatched ); |
| Â | 2448 | } |
| Â | 2449 | |
| Â | 2450 | // Add matches to results |
| Â | 2451 | push.apply( results, setMatched ); |
| Â | 2452 | |
| Â | 2453 | // Seedless set matches succeeding multiple successful matchers stipulate sorting |
| Â | 2454 | if ( outermost && !seed && setMatched.length > 0 && |
| Â | 2455 | ( matchedCount + setMatchers.length ) > 1 ) { |
| Â | 2456 | |
| Â | 2457 | Sizzle.uniqueSort( results ); |
| Â | 2458 | } |
| Â | 2459 | } |
| Â | 2460 | |
| Â | 2461 | // Override manipulation of globals by nested matchers |
| Â | 2462 | if ( outermost ) { |
| Â | 2463 | dirruns = dirrunsUnique; |
| Â | 2464 | outermostContext = contextBackup; |
| Â | 2465 | } |
| Â | 2466 | |
| Â | 2467 | return unmatched; |
| Â | 2468 | }; |
| Â | 2469 | |
| Â | 2470 | return bySet ? |
| Â | 2471 | markFunction( superMatcher ) : |
| Â | 2472 | superMatcher; |
| Â | 2473 | } |
| Â | 2474 | |
| Â | 2475 | compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { |
| Â | 2476 | var i, |
| Â | 2477 | setMatchers = [], |
| Â | 2478 | elementMatchers = [], |
| Â | 2479 | cached = compilerCache[ selector + " " ]; |
| Â | 2480 | |
| Â | 2481 | if ( !cached ) { |
| Â | 2482 | // Generate a function of recursive functions that can be used to check each element |
| Â | 2483 | if ( !match ) { |
| Â | 2484 | match = tokenize( selector ); |
| Â | 2485 | } |
| Â | 2486 | i = match.length; |
| Â | 2487 | while ( i-- ) { |
| Â | 2488 | cached = matcherFromTokens( match[i] ); |
| Â | 2489 | if ( cached[ expando ] ) { |
| Â | 2490 | setMatchers.push( cached ); |
| Â | 2491 | } else { |
| Â | 2492 | elementMatchers.push( cached ); |
| Â | 2493 | } |
| Â | 2494 | } |
| Â | 2495 | |
| Â | 2496 | // Cache the compiled function |
| Â | 2497 | cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); |
| Â | 2498 | |
| Â | 2499 | // Save selector and tokenization |
| Â | 2500 | cached.selector = selector; |
| Â | 2501 | } |
| Â | 2502 | return cached; |
| Â | 2503 | }; |
| Â | 2504 | |
| Â | 2505 | /** |
| Â | 2506 | * A low-level selection function that works with Sizzle's compiled |
| Â | 2507 | * selector functions |
| Â | 2508 | * @param {String|Function} selector A selector or a pre-compiled |
| Â | 2509 | * selector function built with Sizzle.compile |
| Â | 2510 | * @param {Element} context |
| Â | 2511 | * @param {Array} [results] |
| Â | 2512 | * @param {Array} [seed] A set of elements to match against |
| Â | 2513 | */ |
| Â | 2514 | select = Sizzle.select = function( selector, context, results, seed ) { |
| Â | 2515 | var i, tokens, token, type, find, |
| Â | 2516 | compiled = typeof selector === "function" && selector, |
| Â | 2517 | match = !seed && tokenize( (selector = compiled.selector || selector) ); |
| Â | 2518 | |
| Â | 2519 | results = results || []; |
| Â | 2520 | |
| Â | 2521 | // Try to minimize operations if there is no seed and only one group |
| Â | 2522 | if ( match.length === 1 ) { |
| Â | 2523 | |
| Â | 2524 | // Take a shortcut and set the context if the root selector is an ID |
| Â | 2525 | tokens = match[0] = match[0].slice( 0 ); |
| Â | 2526 | if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && |
| Â | 2527 | support.getById && context.nodeType === 9 && documentIsHTML && |
| Â | 2528 | Expr.relative[ tokens[1].type ] ) { |
| Â | 2529 | |
| Â | 2530 | context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; |
| Â | 2531 | if ( !context ) { |
| Â | 2532 | return results; |
| Â | 2533 | |
| Â | 2534 | // Precompiled matchers will still verify ancestry, so step up a level |
| Â | 2535 | } else if ( compiled ) { |
| Â | 2536 | context = context.parentNode; |
| Â | 2537 | } |
| Â | 2538 | |
| Â | 2539 | selector = selector.slice( tokens.shift().value.length ); |
| Â | 2540 | } |
| Â | 2541 | |
| Â | 2542 | // Fetch a seed set for right-to-left matching |
| Â | 2543 | i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; |
| Â | 2544 | while ( i-- ) { |
| Â | 2545 | token = tokens[i]; |
| Â | 2546 | |
| Â | 2547 | // Abort if we hit a combinator |
| Â | 2548 | if ( Expr.relative[ (type = token.type) ] ) { |
| Â | 2549 | break; |
| Â | 2550 | } |
| Â | 2551 | if ( (find = Expr.find[ type ]) ) { |
| Â | 2552 | // Search, expanding context for leading sibling combinators |
| Â | 2553 | if ( (seed = find( |
| Â | 2554 | token.matches[0].replace( runescape, funescape ), |
| Â | 2555 | rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context |
| Â | 2556 | )) ) { |
| Â | 2557 | |
| Â | 2558 | // If seed is empty or no tokens remain, we can return early |
| Â | 2559 | tokens.splice( i, 1 ); |
| Â | 2560 | selector = seed.length && toSelector( tokens ); |
| Â | 2561 | if ( !selector ) { |
| Â | 2562 | push.apply( results, seed ); |
| Â | 2563 | return results; |
| Â | 2564 | } |
| Â | 2565 | |
| Â | 2566 | break; |
| Â | 2567 | } |
| Â | 2568 | } |
| Â | 2569 | } |
| Â | 2570 | } |
| Â | 2571 | |
| Â | 2572 | // Compile and execute a filtering function if one is not provided |
| Â | 2573 | // Provide `match` to avoid retokenization if we modified the selector above |
| Â | 2574 | ( compiled || compile( selector, match ) )( |
| Â | 2575 | seed, |
| Â | 2576 | context, |
| Â | 2577 | !documentIsHTML, |
| Â | 2578 | results, |
| Â | 2579 | rsibling.test( selector ) && testContext( context.parentNode ) || context |
| Â | 2580 | ); |
| Â | 2581 | return results; |
| Â | 2582 | }; |
| Â | 2583 | |
| Â | 2584 | // One-time assignments |
| Â | 2585 | |
| Â | 2586 | // Sort stability |
| Â | 2587 | support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; |
| Â | 2588 | |
| Â | 2589 | // Support: Chrome 14-35+ |
| Â | 2590 | // Always assume duplicates if they aren't passed to the comparison function |
| Â | 2591 | support.detectDuplicates = !!hasDuplicate; |
| Â | 2592 | |
| Â | 2593 | // Initialize against the default document |
| Â | 2594 | setDocument(); |
| Â | 2595 | |
| Â | 2596 | // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) |
| Â | 2597 | // Detached nodes confoundingly follow *each other* |
| Â | 2598 | support.sortDetached = assert(function( div1 ) { |
| Â | 2599 | // Should return 1, but returns 4 (following) |
| Â | 2600 | return div1.compareDocumentPosition( document.createElement("div") ) & 1; |
| Â | 2601 | }); |
| Â | 2602 | |
| Â | 2603 | // Support: IE<8 |
| Â | 2604 | // Prevent attribute/property "interpolation" |
| Â | 2605 | // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx |
| Â | 2606 | if ( !assert(function( div ) { |
| Â | 2607 | div.innerHTML = "<a href='#'></a>"; |
| Â | 2608 | return div.firstChild.getAttribute("href") === "#" ; |
| Â | 2609 | }) ) { |
| Â | 2610 | addHandle( "type|href|height|width", function( elem, name, isXML ) { |
| Â | 2611 | if ( !isXML ) { |
| Â | 2612 | return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); |
| Â | 2613 | } |
| Â | 2614 | }); |
| Â | 2615 | } |
| Â | 2616 | |
| Â | 2617 | // Support: IE<9 |
| Â | 2618 | // Use defaultValue in place of getAttribute("value") |
| Â | 2619 | if ( !support.attributes || !assert(function( div ) { |
| Â | 2620 | div.innerHTML = "<input/>"; |
| Â | 2621 | div.firstChild.setAttribute( "value", "" ); |
| Â | 2622 | return div.firstChild.getAttribute( "value" ) === ""; |
| Â | 2623 | }) ) { |
| Â | 2624 | addHandle( "value", function( elem, name, isXML ) { |
| Â | 2625 | if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { |
| Â | 2626 | return elem.defaultValue; |
| Â | 2627 | } |
| Â | 2628 | }); |
| Â | 2629 | } |
| Â | 2630 | |
| Â | 2631 | // Support: IE<9 |
| Â | 2632 | // Use getAttributeNode to fetch booleans when getAttribute lies |
| Â | 2633 | if ( !assert(function( div ) { |
| Â | 2634 | return div.getAttribute("disabled") == null; |
| Â | 2635 | }) ) { |
| Â | 2636 | addHandle( booleans, function( elem, name, isXML ) { |
| Â | 2637 | var val; |
| Â | 2638 | if ( !isXML ) { |
| Â | 2639 | return elem[ name ] === true ? name.toLowerCase() : |
| Â | 2640 | (val = elem.getAttributeNode( name )) && val.specified ? |
| Â | 2641 | val.value : |
| Â | 2642 | null; |
| Â | 2643 | } |
| Â | 2644 | }); |
| Â | 2645 | } |
| Â | 2646 | |
| Â | 2647 | return Sizzle; |
| Â | 2648 | |
| Â | 2649 | })( window ); |
| Â | 2650 | |
| Â | 2651 | |
| Â | 2652 | |
| Â | 2653 | jQuery.find = Sizzle; |
| Â | 2654 | jQuery.expr = Sizzle.selectors; |
| Â | 2655 | jQuery.expr[":"] = jQuery.expr.pseudos; |
| Â | 2656 | jQuery.unique = Sizzle.uniqueSort; |
| Â | 2657 | jQuery.text = Sizzle.getText; |
| Â | 2658 | jQuery.isXMLDoc = Sizzle.isXML; |
| Â | 2659 | jQuery.contains = Sizzle.contains; |
| Â | 2660 | |
| Â | 2661 | |
| Â | 2662 | |
| Â | 2663 | var rneedsContext = jQuery.expr.match.needsContext; |
| Â | 2664 | |
| Â | 2665 | var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/); |
| Â | 2666 | |
| Â | 2667 | |
| Â | 2668 | |
| Â | 2669 | var risSimple = /^.[^:#\[\.,]*$/; |
| Â | 2670 | |
| Â | 2671 | // Implement the identical functionality for filter and not |
| Â | 2672 | function winnow( elements, qualifier, not ) { |
| Â | 2673 | if ( jQuery.isFunction( qualifier ) ) { |
| Â | 2674 | return jQuery.grep( elements, function( elem, i ) { |
| Â | 2675 | /* jshint -W018 */ |
| Â | 2676 | return !!qualifier.call( elem, i, elem ) !== not; |
| Â | 2677 | }); |
| Â | 2678 | |
| Â | 2679 | } |
| Â | 2680 | |
| Â | 2681 | if ( qualifier.nodeType ) { |
| Â | 2682 | return jQuery.grep( elements, function( elem ) { |
| Â | 2683 | return ( elem === qualifier ) !== not; |
| Â | 2684 | }); |
| Â | 2685 | |
| Â | 2686 | } |
| Â | 2687 | |
| Â | 2688 | if ( typeof qualifier === "string" ) { |
| Â | 2689 | if ( risSimple.test( qualifier ) ) { |
| Â | 2690 | return jQuery.filter( qualifier, elements, not ); |
| Â | 2691 | } |
| Â | 2692 | |
| Â | 2693 | qualifier = jQuery.filter( qualifier, elements ); |
| Â | 2694 | } |
| Â | 2695 | |
| Â | 2696 | return jQuery.grep( elements, function( elem ) { |
| Â | 2697 | return ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not; |
| Â | 2698 | }); |
| Â | 2699 | } |
| Â | 2700 | |
| Â | 2701 | jQuery.filter = function( expr, elems, not ) { |
| Â | 2702 | var elem = elems[ 0 ]; |
| Â | 2703 | |
| Â | 2704 | if ( not ) { |
| Â | 2705 | expr = ":not(" + expr + ")"; |
| Â | 2706 | } |
| Â | 2707 | |
| Â | 2708 | return elems.length === 1 && elem.nodeType === 1 ? |
| Â | 2709 | jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] : |
| Â | 2710 | jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { |
| Â | 2711 | return elem.nodeType === 1; |
| Â | 2712 | })); |
| Â | 2713 | }; |
| Â | 2714 | |
| Â | 2715 | jQuery.fn.extend({ |
| Â | 2716 | find: function( selector ) { |
| Â | 2717 | var i, |
| Â | 2718 | ret = [], |
| Â | 2719 | self = this, |
| Â | 2720 | len = self.length; |
| Â | 2721 | |
| Â | 2722 | if ( typeof selector !== "string" ) { |
| Â | 2723 | return this.pushStack( jQuery( selector ).filter(function() { |
| Â | 2724 | for ( i = 0; i < len; i++ ) { |
| Â | 2725 | if ( jQuery.contains( self[ i ], this ) ) { |
| Â | 2726 | return true; |
| Â | 2727 | } |
| Â | 2728 | } |
| Â | 2729 | }) ); |
| Â | 2730 | } |
| Â | 2731 | |
| Â | 2732 | for ( i = 0; i < len; i++ ) { |
| Â | 2733 | jQuery.find( selector, self[ i ], ret ); |
| Â | 2734 | } |
| Â | 2735 | |
| Â | 2736 | // Needed because $( selector, context ) becomes $( context ).find( selector ) |
| Â | 2737 | ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret ); |
| Â | 2738 | ret.selector = this.selector ? this.selector + " " + selector : selector; |
| Â | 2739 | return ret; |
| Â | 2740 | }, |
| Â | 2741 | filter: function( selector ) { |
| Â | 2742 | return this.pushStack( winnow(this, selector || [], false) ); |
| Â | 2743 | }, |
| Â | 2744 | not: function( selector ) { |
| Â | 2745 | return this.pushStack( winnow(this, selector || [], true) ); |
| Â | 2746 | }, |
| Â | 2747 | is: function( selector ) { |
| Â | 2748 | return !!winnow( |
| Â | 2749 | this, |
| Â | 2750 | |
| Â | 2751 | // If this is a positional/relative selector, check membership in the returned set |
| Â | 2752 | // so $("p:first").is("p:last") won't return true for a doc with two "p". |
| Â | 2753 | typeof selector === "string" && rneedsContext.test( selector ) ? |
| Â | 2754 | jQuery( selector ) : |
| Â | 2755 | selector || [], |
| Â | 2756 | false |
| Â | 2757 | ).length; |
| Â | 2758 | } |
| Â | 2759 | }); |
| Â | 2760 | |
| Â | 2761 | |
| Â | 2762 | // Initialize a jQuery object |
| Â | 2763 | |
| Â | 2764 | |
| Â | 2765 | // A central reference to the root jQuery(document) |
| Â | 2766 | var rootjQuery, |
| Â | 2767 | |
| Â | 2768 | // Use the correct document accordingly with window argument (sandbox) |
| Â | 2769 | document = window.document, |
| Â | 2770 | |
| Â | 2771 | // A simple way to check for HTML strings |
| Â | 2772 | // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) |
| Â | 2773 | // Strict HTML recognition (#11290: must start with <) |
| Â | 2774 | rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, |
| Â | 2775 | |
| Â | 2776 | init = jQuery.fn.init = function( selector, context ) { |
| Â | 2777 | var match, elem; |
| Â | 2778 | |
| Â | 2779 | // HANDLE: $(""), $(null), $(undefined), $(false) |
