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