https://www.reach-clp-biozid-helpdesk.de/SiteGlobals/Frontend/Java…/global.js?v=5&nn=6942652c85ec843c18743a51

79            return !!~("" + a).indexOf(b)
80        }
81
82        function C(a, b, d) {
83            for (var e in a) {
84                var f = b[a[e]];
85                if (f !== c) return d === !1 ? a[e] : A(f, "function") ? f.bind(d || b) : f
86            }
87            return !1
88        }
89        var d = "2.6.2",
90            e = {},
91            f = !0,
92            g = b.documentElement,
93            h = "modernizr",
94            i = b.createElement(h),
95            j = i.style,
96            k, l = {}.toString,
97            m = " -webkit- -moz- -o- -ms- ".split(" "),
98            n = {
99                svg: "http://www.w3.org/2000/svg"
100            },
101            o = {},
102            p = {},
103            q = {},
104            r = [],
105            s = r.slice,
106            t, u = function(a, c, d, e) {
107                var f, i, j, k, l = b.createElement("div"),
108                    m = b.body,
109                    n = m || b.createElement("body");
110                if (parseInt(d, 10))
111                    while (d--) j = b.createElement("div"), j.id = e ? e[d] : h + (d + 1), l.appendChild(j);
112                return f = ["&#173;", '<style id="s', h, '">', a, "</style>"].join(""), l.id = h, (m ? l : n).innerHTML += f, n.appendChild(l), m || (n.style.background = "", n.style.overflow = "hidden", k = g.style.overflow, g.style.overflow = "hidden", g.appendChild(n)), i = c(l, a), m ? l.parentNode.removeChild(l) : (n.parentNode.removeChild(n), g.style.overflow = k), !!i
113            },
114            v = function(b) {
115                var c = a.matchMedia || a.msMatchMedia;
116                if (c) return c(b).matches;
117                var d;
118                return u("@media " + b + " { #" + h + " { position: absolute; } }", function(b) {
119                    d = (a.getComputedStyle ? getComputedStyle(b, null) : b.currentStyle)["position"] == "absolute"
120                }), d
121            },
122            w = {}.hasOwnProperty,
123            x;
124        !A(w, "undefined") && !A(w.call, "undefined") ? x = function(a, b) {
125            return w.call(a, b)
126        } : x = function(a, b) {
127            return b in a && A(a.constructor.prototype[b], "undefined")
128        }, Function.prototype.bind || (Function.prototype.bind = function(b) {
129            var c = this;
130            if (typeof c != "function") throw new TypeError;
131            var d = s.call(arguments, 1),
132                e = function() {
133                    if (this instanceof e) {
134                        var a = function() {};
135                        a.prototype = c.prototype;
136                        var f = new a,
137                            g = c.apply(f, d.concat(s.call(arguments)));
138                        return Object(g) === g ? g : f
139                    }
140                    return c.apply(b, d.concat(s.call(arguments)))
141                };
142            return e
143        }), o.touch = function() {
144            var c;
145            return "ontouchstart" in a || a.DocumentTouch && b instanceof DocumentTouch ? c = !0 : u(["@media (", m.join("touch-enabled),("), h, ")", "{#modernizr{top:9px;position:absolute}}"].join(""), function(a) {
146                c = a.offsetTop === 9
147            }), c
148        }, o.svg = function() {
149            return !!b.createElementNS && !!b.createElementNS(n.svg, "svg").createSVGRect
150        }, o.inlinesvg = function() {
151            var a = b.createElement("div");
152            return a.innerHTML = "<svg/>", (a.firstChild && a.firstChild.namespaceURI) == n.svg
153        }, o.svgclippaths = function() {
154            return !!b.createElementNS && /SVGClipPath/.test(l.call(b.createElementNS(n.svg, "clipPath")))
155        };
156        for (var D in o) x(o, D) && (t = D.toLowerCase(), e[t] = o[D](), r.push((e[t] ? "" : "no-") + t));
157        return e.addTest = function(a, b) {
158                if (typeof a == "object")
159                    for (var d in a) x(a, d) && e.addTest(d, a[d]);
160                else {
161                    a = a.toLowerCase();
162                    if (e[a] !== c) return e;
163                    b = typeof b == "function" ? b() : b, typeof f != "undefined" && f && (g.className += " " + (b ? "" : "no-") + a), e[a] = b
164                }
165                return e
166            }, y(""), i = k = null,
167            function(a, b) {
168                function k(a, b) {
169                    var c = a.createElement("p"),
170                        d = a.getElementsByTagName("head")[0] || a.documentElement;
171                    return c.innerHTML = "x<style>" + b + "</style>", d.insertBefore(c.lastChild, d.firstChild)
172                }
173
174                function l() {
175                    var a = r.elements;
176                    return typeof a == "string" ? a.split(" ") : a
177                }
178
179                function m(a) {
180                    var b = i[a[g]];
181                    return b || (b = {}, h++, a[g] = h, i[h] = b), b
182                }
183
184                function n(a, c, f) {
185                    c || (c = b);
186                    if (j) return c.createElement(a);
187                    f || (f = m(c));
188                    var g;
189                    return f.cache[a] ? g = f.cache[a].cloneNode() : e.test(a) ? g = (f.cache[a] = f.createElem(a)).cloneNode() : g = f.createElem(a), g.canHaveChildren && !d.test(a) ? f.frag.appendChild(g) : g
190                }
191
192                function o(a, c) {
193                    a || (a = b);
194                    if (j) return a.createDocumentFragment();
195                    c = c || m(a);
196                    var d = c.frag.cloneNode(),
197                        e = 0,
198                        f = l(),
199                        g = f.length;
200                    for (; e < g; e++) d.createElement(f[e]);
201                    return d
202                }
203
204                function p(a, b) {
205                    b.cache || (b.cache = {}, b.createElem = a.createElement, b.createFrag = a.createDocumentFragment, b.frag = b.createFrag()), a.createElement = function(c) {
206                        return r.shivMethods ? n(c, a, b) : b.createElem(c)
207                    }, a.createDocumentFragment = Function("h,f", "return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&(" + l().join().replace(/\w+/g, function(a) {
208                        return b.createElem(a), b.frag.createElement(a), 'c("' + a + '")'
209                    }) + ");return n}")(r, b.frag)
210                }
211
212                function q(a) {
213                    a || (a = b);
214                    var c = m(a);
215                    return r.shivCSS && !f && !c.hasCSS && (c.hasCSS = !!k(a, "article,aside,figcaption,figure,footer,header,hgroup,nav,section{dis

215play:block}mark{background:#FF0;color:#000}")), j || p(a, c), a
216                }
217                var c = a.html5 || {},
218                    d = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,
219                    e = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,
220                    f, g = "_html5shiv",
221                    h = 0,
222                    i = {},
223                    j;
224                (function() {
225                    try {
226                        var a = b.createElement("a");
227                        a.innerHTML = "<xyz></xyz>", f = "hidden" in a, j = a.childNodes.length == 1 || function() {
228                            b.createElement("a");
229                            var a = b.createDocumentFragment();
230                            return typeof a.cloneNode == "undefined" || typeof a.createDocumentFragment == "undefined" || typeof a.createElement == "undefined"
231                        }()
232                    } catch (c) {
233                        f = !0, j = !0
234                    }
235                })();
236                var r = {
237                    elements: c.elements || "abbr article aside audio bdi canvas data datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video",
238                    shivCSS: c.shivCSS !== !1,
239                    supportsUnknownElements: j,
240                    shivMethods: c.shivMethods !== !1,
241                    type: "default",
242                    shivDocument: q,
243                    createElement: n,
244                    createDocumentFragment: o
245                };
246                a.html5 = r, q(b)
247            }(this, b), e._version = d, e._prefixes = m, e.mq = v, e.testStyles = u, g.className = g.className.replace(/(^|\s)no-js(\s|$)/, "$1$2") + (f ? " js " + r.join(" ") : ""), e
248    }(this, this.document),
249    function(a, b, c) {
250        function d(a) {
251            return "[object Function]" == o.call(a)
252        }
253
254        function e(a) {
255            return "string" == typeof a
256        }
257
258        function f() {}
259
260        function g(a) {
261            return !a || "loaded" == a || "complete" == a || "uninitialized" == a
262        }
263
264        function h() {
265            var a = p.shift();
266            q = 1, a ? a.t ? m(function() {
267                ("c" == a.t ? B.injectCss : B.injectJs)(a.s, 0, a.a, a.x, a.e, 1)
268            }, 0) : (a(), h()) : q = 0
269        }
270
271        function i(a, c, d, e, f, i, j) {
272            function k(b) {
273                if (!o && g(l.readyState) && (u.r = o = 1, !q && h(), l.onload = l.onreadystatechange = null, b)) {
274                    "img" != a && m(function() {
275                        t.removeChild(l)
276                    }, 50);
277                    for (var d in y[c]) y[c].hasOwnProperty(d) && y[c][d].onload()
278                }
279            }
280            var j = j || B.errorTimeout,
281                l = b.createElement(a),
282                o = 0,
283                r = 0,
284                u = {
285                    t: d,
286                    s: c,
287                    e: f,
288                    a: i,
289                    x: j
290                };
291            1 === y[c] && (r = 1, y[c] = []), "object" == a ? l.data = c : (l.src = c, l.type = a), l.width = l.height = "0", l.onerror = l.onload = l.onreadystatechange = function() {
292                k.call(this, r)
293            }, p.splice(e, 0, u), "img" != a && (r || 2 === y[c] ? (t.insertBefore(l, s ? null : n), m(k, j)) : y[c].push(l))
294        }
295
296        function j(a, b, c, d, f) {
297            return q = 0, b = b || "j", e(a) ? i("c" == b ? v : u, a, b, this.i++, c, d, f) : (p.splice(this.i++, 0, a), 1 == p.length && h()), this
298        }
299
300        function k() {
301            var a = B;
302            return a.loader = {
303                load: j,
304                i: 0
305            }, a
306        }
307        var l = b.documentElement,
308            m = a.setTimeout,
309            n = b.getElementsByTagName("script")[0],
310            o = {}.toString,
311            p = [],
312            q = 0,
313            r = "MozAppearance" in l.style,
314            s = r && !!b.createRange().compareNode,
315            t = s ? l : n.parentNode,
316            l = a.opera && "[object Opera]" == o.call(a.opera),
317            l = !!b.attachEvent && !l,
318            u = r ? "object" : l ? "script" : "img",
319            v = l ? "script" : u,
320            w = Array.isArray || function(a) {
321                return "[object Array]" == o.call(a)
322            },
323            x = [],
324            y = {},
325            z = {
326                timeout: function(a, b) {
327                    return b.length && (a.timeout = b[0]), a
328                }
329            },
330            A, B;
331        B = function(a) {
332            function b(a) {
333                var a = a.split("!"),
334                    b = x.length,
335                    c = a.pop(),
336                    d = a.length,
337                    c = {
338                        url: c,
339                        origUrl: c,
340                        prefixes: a
341                    },
342                    e, f, g;
343                for (f = 0; f < d; f++) g = a[f].split("="), (e = z[g.shift()]) && (c = e(c, g));
344                for (f = 0; f < b; f++) c = x[f](c);
345                return c
346            }
347
348            function g(a, e, f, g, h) {
349                var i = b(a),
350                    j = i.autoCallback;
351                i.url.split(".").pop().split("?").shift(), i.bypass || (e && (e = d(e) ? e : e[a] || e[g] || e[a.split("/").pop().split("?")[0]]), i.instead ? i.instead(a, e, f, g, h) : (y[i.url] ? i.noexec = !0 : y[i.url] = 1, f.load(i.url, i.forceCSS || !i.forceJS && "css" == i.url.split(".").pop().split("?").shift() ? "c" : c, i.noexec, i.attrs, i.timeout), (d(e) || d(j)) && f.load(function() {
352                    k(), e && e(i.origUrl, h, g), j && j(i.origUrl, h, g), y[i.url] = 2
353                })))
354            }
355
356            function h(a, b) {
357                function c(a, c) {
358                    if (a) {
359                        if (e(a)) c || (j = function() {
360                            var a = [].slice.call(arguments);
361                            k.apply(this, a), l()
362                        }), g(a, j, b, 0, h);
363                        else if (Object(a) === a)
364                            for (n in m = function() {
365                                    var b = 0,
366                                        c;
367                                    for (c in a) a.hasOwnProperty(c) && b++;
368                                    return b
369                                }(), a) a.hasOwnProperty(n) && (!c && !--m && (d(j) ? j = function() {
370                                var a = [].slice.call(arguments);
371                                k.apply(this, a), l()
372                            } : j[n] = function(a) {
373                                return function() {
374                                    var b = [].slice.call(arguments);
375                                    a && a.apply(this, b), l()
376                                }
377                            }(k[n])), g(a[n], j, b, n, h))
378                    } else !c && l()
379                }
380                var h = !!a.test,
381                    i = a.load || a.both,
382                    j = a.callback || f,
383                    k = j,
384                    l = a.complete || f,
385                    m, n;
386                c(h ? a.yep : a.nope, !!i), i && c(i)
387            }
388            var i, j, l = this.yepnope.loader;
389            if (e(a)) g(a, 0, l, 0);
390            else if (w(a))
391                for (i = 0; i < a.length; i++) j = a[i], e(j) ? g(j, 0, l, 0) : w(j) ? B(j) : Object(j) === j && h(j, l);
392            else Object(a) === a && h(a, l)
393        }, B.addPrefix = function(a, b) {
394            z[a] = b
395        }, B.addFilter = function(a) {
396            x.push(a)
397        }, B.errorTimeout = 1e4, null == b.readyState && b.addEventListener && (b.readyState = "loading", b.addEventListener("DOMContentLoaded", A = function() {
398            b.removeEventListener("DOMContentLoaded", A, 0), b.readyState = "complete"
399        }, 0)), a.yepnope = k(), a.yepnope.executeStack = h, a.yepnope.injectJs = function(a, c, d, e, i, j) {
400            var k = b.createElement("script"),
401                l, o, e = e || B.errorTimeout;
402            k.src = a;
403            for (o in d) k.setAttribute(o, d[o]);
404            c = j ? h : c || f, k.onreadystatechange = k.onload = function() {
405                !l && g(k.readyState) && (l = 1, c(), k.onload = k.onreadystatechange = null)
406            }, m(function() {
407                l || (l = 1, c(1))
408            }, e), i ? k.onload() : n.parentNode.insertBefore(k, n)
409        }, a.yepnope.injectCss = function(a, c, d, e, g, i) {
410            var e = b.createElement("link"),
411                j, c = i ? h : c || f;
412            e.href = a, e.rel = "stylesheet", e.type = "text/css";
413            for (j in d) e.setAttribute(j, d[j]);
414            g || (n.parentNode.insertBefore(e, n), m(c, 0))
415        }
416    }(this, document), Modernizr.load = function() {
417        yepnope.apply(window, [].slice.call(arguments, 0))
418    }, Modernizr.addTest("ie8compat", function() {
419        return !window.addEventListener && document.documentMode && document.documentMode === 7
420    });
421   /* Ende custom.modernizr */
422   /* Start jquery */
423   /*!
424 * jQuery JavaScript Library v1.11.1
425 * http://jquery.com/
426 *
427 * Includes Sizzle.js
428 * http://sizzlejs.com/
429 *
430 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
431 * Released under the MIT license
432 * http://jquery.org/license
433 *
434 * Date: 2014-05-01T17:42Z
435 */
436
437(function( global, factory ) {
438
439 if ( typeof module === "object" && typeof module.exports === "object" ) {
440  // For CommonJS and CommonJS-like environments where a proper window is present,
441  // execute the factory and get jQuery
442  // For environments that do not inherently posses a window with a document
443  // (such as Node.js), expose a jQuery-making factory as module.exports
444  // This accentuates the need for the creation of a real window
445  // e.g. var jQuery = require("jquery")(window);
446  // See ticket #14549 for more info
447  module.exports = global.document ?
448   factory( global, true ) :
449   function( w ) {
450    if ( !w.document ) {
451     throw new Error( "jQuery requires a window with a document" );
452    }
453    return factory( w );
454   };
455 } else {
456  factory( global );
457 }
458
459// Pass this if window is not defined yet
460}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
461
462// Can't do this because several apps including ASP.NET trace
463// the stack via arguments.caller.callee and Firefox dies if
464// you try to trace through "use strict" call chains. (#13335)
465// Support: Firefox 18+
466//
467
468var deletedIds = [];
469
470var slice = deletedIds.slice;
471
472var concat = deletedIds.concat;
473
474var push = deletedIds.push;
475
476var indexOf = deletedIds.indexOf;
477
478var class2type = {};
479
480var toString = class2type.toString;
481
482var hasOwn = class2type.hasOwnProperty;
483
484var support = {};
485
486var
487 version = "1.11.1",
488
489 // Define a local copy of jQuery
490 jQuery = function( selector, context ) {
491  // The jQuery object is actually just the init constructor 'enhanced'
492  // Need init if jQuery is called (just allow error to be thrown if not included)
493  return new jQuery.fn.init( selector, context );
494 },
495
496 // Support: Android<4.1, IE<9
497 // Make sure we trim BOM and NBSP
498 rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
499
500 // Matches dashed string for camelizing
501 rmsPrefix = /^-ms-/,
502 rdashAlpha = /-([\da-z])/gi,
503
504 // Used by jQuery.camelCase as callback to replace()
505 fcamelCase = function( all, letter ) {
506  return letter.toUpperCase();
507 };
508
509jQuery.fn = jQuery.prototype = {
510 // The current version of jQuery being used
511 jquery: version,
512
513 constructor: jQuery,
514
515 // Start with an empty selector
516 selector: "",
517
518 // The default length of a jQuery object is 0
519 length: 0,
520
521 toArray: function() {
522  return slice.call( this );
523 },
524
525 // Get the Nth element in the matched element set OR
526 // Get the whole matched element set as a clean array
527 get: function( num ) {
528  return num != null ?
529
530   // Return just the one element from the set
531   ( num < 0 ? this[ num + this.length ] : this[ num ] ) :
532
533   // Return all the elements in a clean array
534   slice.call( this );
535 },
536
537 // Take an array of elements and push it onto the stack
538 // (returning the new matched element set)
539 pushStack: function( elems ) {
540
541  // Build a new jQuery matched element set
542  var ret = jQuery.merge( this.constructor(), elems );
543
544  // Add the old object onto the stack (as a reference)

545  ret.prevObject = this;
546  ret.context = this.context;
547
548  // Return the newly-formed element set
549  return ret;
550 },
551
552 // Execute a callback for every element in the matched set.
553 // (You can seed the arguments with an array of args, but this is
554 // only used internally.)
555 each: function( callback, args ) {
556  return jQuery.each( this, callback, args );
557 },
558
559 map: function( callback ) {
560  return this.pushStack( jQuery.map(this, function( elem, i ) {
561   return callback.call( elem, i, elem );
562  }));
563 },
564
565 slice: function() {
566  return this.pushStack( slice.apply( this, arguments ) );
567 },
568
569 first: function() {
570  return this.eq( 0 );
571 },
572
573 last: function() {
574  return this.eq( -1 );
575 },
576
577 eq: function( i ) {
578  var len = this.length,
579   j = +i + ( i < 0 ? len : 0 );
580  return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
581 },
582
583 end: function() {
584  return this.prevObject || this.constructor(null);
585 },
586
587 // For internal use only.
588 // Behaves like an Array's method, not like a jQuery method.
589 push: push,
590 sort: deletedIds.sort,
591 splice: deletedIds.splice
592};
593
594jQuery.extend = jQuery.fn.extend = function() {
595 var src, copyIsArray, copy, name, options, clone,
596  target = arguments[0] || {},
597  i = 1,
598  length = arguments.length,
599  deep = false;
600
601 // Handle a deep copy situation
602 if ( typeof target === "boolean" ) {
603  deep = target;
604
605  // skip the boolean and the target
606  target = arguments[ i ] || {};
607  i++;
608 }
609
610 // Handle case when target is a string or something (possible in deep copy)
611 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
612  target = {};
613 }
614
615 // extend jQuery itself if only one argument is passed
616 if ( i === length ) {
617  target = this;
618  i--;
619 }
620
621 for ( ; i < length; i++ ) {
622  // Only deal with non-null/undefined values
623  if ( (options = arguments[ i ]) != null ) {
624   // Extend the base object
625   for ( name in options ) {
626    src = target[ name ];
627    copy = options[ name ];
628
629    // Prevent never-ending loop
630    if ( target === copy ) {
631     continue;
632    }
633
634    // Recurse if we're merging plain objects or arrays
635    if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
636     if ( copyIsArray ) {
637      copyIsArray = false;
638      clone = src && jQuery.isArray(src) ? src : [];
639
640     } else {
641      clone = src && jQuery.isPlainObject(src) ? src : {};
642     }
643
644     // Never move original objects, clone them
645     target[ name ] = jQuery.extend( deep, clone, copy );
646
647    // Don't bring in undefined values
648    } else if ( copy !== undefined ) {
649     target[ name ] = copy;
650    }
651   }
652  }
653 }
654
655 // Return the modified object
656 return target;
657};
658
659jQuery.extend({
660 // Unique for each copy of jQuery on the page
661 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
662
663 // Assume jQuery is ready without the ready module
664 isReady: true,
665
666 error: function( msg ) {
667  throw new Error( msg );
668 },
669
670 noop: function() {},
671
672 // See test/unit/core.js for details concerning isFunction.
673 // Since version 1.3, DOM methods and functions like alert
674 // aren't supported. They return false on IE (#2968).
675 isFunction: function( obj ) {
676  return jQuery.type(obj) === "function";
677 },
678
679 isArray: Array.isArray || function( obj ) {
680  return jQuery.type(obj) === "array";
681 },
682
683 isWindow: function( obj ) {
684  /* jshint eqeqeq: false */
685  return obj != null && obj == obj.window;
686 },
687
688 isNumeric: function( obj ) {
689  // parseFloat NaNs numeric-cast false positives (null|true|false|"")
690  // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
691  // subtraction forces infinities to NaN
692  return !jQuery.isArray( obj ) && obj - parseFloat( obj ) >= 0;
693 },
694
695 isEmptyObject: function( obj ) {
696  var name;
697  for ( name in obj ) {
698   return false;
699  }
700  return true;
701 },
702
703 isPlainObject: function( obj ) {
704  var key;
705
706  // Must be an Object.
707  // Because of IE, we also have to check the presence of the constructor property.
708  // Make sure that DOM nodes and window objects don't pass through, as well
709  if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
710   return false;
711  }
712
713  try {
714   // Not own constructor property must be Object
715   if ( obj.constructor &&
716    !hasOwn.call(obj, "constructor") &&
717    !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
718    return false;
719   }
720  } catch ( e ) {
721   // IE8,9 Will throw exceptions on certain host objects #9897
722   return false;
723  }
724
725  // Support: IE<9
726  // Handle iteration over inherited properties before own properties.
727  if ( support.ownLast ) {
728   for ( key in obj ) {
729    return hasOwn.call( obj, key );
730   }
731  }
732
733  // Own properties are enumerated firstly, so to speed up,
734  // if last one is own, then all properties are own.
735  for ( key in obj ) {}
736
737  return key === undefined || hasOwn.call( obj, key );
738 },
739
740 type: function( obj ) {
741  if ( obj == null ) {
742   return obj + "";
743  }
744  return typeof obj === "object" || typeof obj === "function" ?
745   class2type[ toString.call(obj) ] || "object" :
746   typeof obj;
747 },
748
749 // Evaluates a script in a global context
750 // Workarounds based on findings by Jim Driscoll
751 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
752 globalEval: function( data ) {
753  if ( data && jQuery.trim( data ) ) {
754   // We use execScript on Internet Explorer
755   // We use an anonymous function so that context is window
756   // rather than jQuery in Firefox
757   ( window.execScript || function( data ) {
758    window[ "eval" ].call( window, data );
759   } )( data );
760  }
761 },
762
763 // Convert dashed to camelCase; used by the css and data modules
764 // Microsoft forgot to hump their vendor prefix (#9572)
765 camelCase: function( string ) {
766  return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
767 },
768
769 nodeName: function( elem, name ) {
770  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
771 },
772
773 // args is for internal usage only
774 each: function( obj, callback, args ) {
775  var value,
776   i = 0,
777   length = obj.length,
778   isArray = isArraylike( obj );
779
780  if ( args ) {
781   if ( isArray ) {
782    for ( ; i < length; i++ ) {
783     value = callback.apply( obj[ i ], args );
784
785     if ( value === false ) {
786      break;
787     }
788    }
789   } else {
790    for ( i in obj ) {
791     value = callback.apply( obj[ i ], args );
792
793     if ( value === false ) {
794      break;
795     }
796    }
797   }
798
799  // A special, fast, case for the most common use of each
800  } else {
801   if ( isArray ) {
802    for ( ; i < length; i++ ) {
803     value = callback.call( obj[ i ], i, obj[ i ] );
804
805     if ( value === false ) {
806      break;
807     }
808    }
809   } else {
810    for ( i in obj ) {
811     value = callback.call( obj[ i ], i, obj[ i ] );
812
813     if ( value === false ) {
814      break;
815     }
816    }
817   }
818  }
819
820  return obj;
821 },
822
823 // Support: Android<4.1, IE<9
824 trim: function( text ) {
825  return text == null ?
826   "" :
827   ( text + "" ).replace( rtrim, "" );
828 },
829
830 // results is for internal usage only
831 makeArray: function( arr, results ) {
832  var ret = results || [];
833
834  if ( arr != null ) {
835   if ( isArraylike( Object(arr) ) ) {
836    jQuery.merge( ret,
837     typeof arr === "string" ?
838     [ arr ] : arr
839    );
840   } else {
841    push.call( ret, arr );
842   }
843  }
844
845  return ret;
846 },
847
848 inArray: function( elem, arr, i ) {
849  var len;
850
851  if ( arr ) {
852   if ( indexOf ) {
853    return indexOf.call( arr, elem, i );
854   }
855
856   len = arr.length;
857   i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
858
859   for ( ; i < len; i++ ) {
860    // Skip accessing in sparse arrays
861    if ( i in arr && arr[ i ] === elem ) {
862     return i;
863    }
864   }
865  }
866
867  return -1;
868 },
869
870 merge: function( first, second ) {
871  var len = +second.length,
872   j = 0,
873   i = first.length;
874
875  while ( j < len ) {
876   first[ i++ ] = second[ j++ ];
877  }
878
879  // Support: IE<9
880  // Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
881  if ( len !== len ) {
882   while ( second[j] !== undefined ) {
883    first[ i++ ] = second[ j++ ];
884   }
885  }
886
887  first.length = i;
888
889  return first;
890 },
891
892 grep: function( elems, callback, invert ) {
893  var callbackInverse,
894   matches = [],
895   i = 0,
896   length = elems.length,
897   callbackExpect = !invert;
898
899  // Go through the array, only saving the items
900  // that pass the validator function
901  for ( ; i < length; i++ ) {
902   callbackInverse = !callback( elems[ i ], i );
903   if ( callbackInverse !== callbackExpect ) {
904    matches.push( elems[ i ] );
905   }
906  }
907
908  return matches;
909 },
910
911 // arg is for internal usage only
912 map: function( elems, callback, arg ) {
913  var value,
914   i = 0,
915   length = elems.length,
916   isArray = isArraylike( elems ),
917   ret = [];
918
919  // Go through the array, translating each of the items to their new values
920  if ( isArray ) {
921   for ( ; i < length; i++ ) {
922    value = callback( elems[ i ], i, arg );
923
924    if ( value != null ) {
925     ret.push( value );
926    }
927   }
928
929  // Go through every key on the object,
930  } else {
931   for ( i in elems ) {
932    value = callback( elems[ i ], i, arg );
933
934    if ( value != null ) {
935     ret.push( value );
936    }
937   }
938  }
939
940  // Flatten any nested arrays
941  return concat.apply( [], ret );
942 },
943
944 // A global GUID counter for objects
945 guid: 1,
946
947 // Bind a function to a context, optionally partially applying any
948 // arguments.
949 proxy: function( fn, context ) {
950  var args, proxy, tmp;
951
952  if ( typeof context === "string" ) {
953   tmp = fn[ context ];
954   context = fn;
955   fn = tmp;
956  }
957
958  // Quick check to determine if target is callable, in the spec
959  // this throws a TypeError, but we will just return undefined.
960  if ( !jQuery.isFunction( fn ) ) {
961   return undefined;
962  }
963
964  // Simulated bind
965  args = slice.call( arguments, 2 );
966  proxy = function() {
967   return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
968  };
969
970  // Set the guid of unique handler to the same of original handler, so it can be removed
971  proxy.guid = fn.guid = fn.guid || jQuery.guid++;
972
973  return proxy;
974 },
975
976 now: function() {
977  return +( new Date() );
978 },
979
980 // jQuery.support is not used in Core but other projects attach their
981 // properties to it so it needs to exist.
982 support: support
983});
984
985// Populate the class2type map
986jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
987 class2type[ "[object " + name + "]" ] = name.toLowerCase();
988});
989
990function isArraylike( obj ) {
991 var length = obj.length,
992  type = jQuery.type( obj );
993
994 if ( type === "function" || jQuery.isWindow( obj ) ) {
995  return false;
996 }
997
998 if ( obj.nodeType === 1 && length ) {
999  return true;
1000 }
1001
1002 return type === "array" || length === 0 ||
1003  typeof length === "number" && length > 0 && ( length - 1 ) in obj;
1004}
1005var Sizzle =
1006/*!
1007 * Sizzle CSS Selector Engine v1.10.19
1008 * http://sizzlejs.com/
1009 *
1010 * Copyright 2013 jQuery Foundation, Inc. and other contributors
1011 * Released under the MIT license
1012 * http://jquery.org/license
1013 *
1014 * Date: 2014-04-18
1015 */
1016(function( window ) {
1017
1018var i,
1019 support,
1020 Expr,
1021 getText,
1022 isXML,
1023 tokenize,
1024 compile,
1025 select,
1026 outermostContext,
1027 sortInput,
1028 hasDuplicate,
1029
1030 // Local document vars
1031 setDocument,
1032 document,
1033 docElem,
1034 documentIsHTML,
1035 rbuggyQSA,
1036 rbuggyMatches,
1037 matches,
1038 contains,
1039
1040 // Instance-specific data
1041 expando = "sizzle" + -(new Date()),
1042 preferredDoc = window.document,
1043 dirruns = 0,
1044 done = 0,
1045 classCache = createCache(),
1046 tokenCache = createCache(),
1047 compilerCache = createCache(),
1048 sortOrder = function( a, b ) {
1049  if ( a === b ) {
1050   hasDuplicate = true;
1051  }
1052  return 0;
1053 },
1054
1055 // General-purpose constants
1056 strundefined = typeof undefined,
1057 MAX_NEGATIVE = 1 << 31,
1058
1059 // Instance methods
1060 hasOwn = ({}).hasOwnProperty,
1061 arr = [],
1062 pop = arr.pop,
1063 push_native = arr.push,
1064 push = arr.push,
1065 slice = arr.slice,
1066 // Use a stripped-down indexOf if we can't use a native one
1067 indexOf = arr.indexOf || function( elem ) {
1068  var i = 0,
1069   len = this.length;
1070  for ( ; i < len; i++ ) {
1071   if ( this[i] === elem ) {
1072    return i;
1073   }
1074  }
1075  return -1;
1076 },
1077
1078 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
1079
1080 // Regular expressions
1081
1082 // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
1083 whitespace = "[\\x20\\t\\r\\n\\f]",
1084 // http://www.w3.org/TR/css3-syntax/#characters
1085 characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
1086
1087 // Loosely modeled on CSS identifier characters
1088 // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
1089 // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
1090 identifier = characterEncoding.replace( "w", "w#" ),
1091
1092 // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
1093 attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
1094  // Operator (capture 2)
1095  "*([*^$|!~]?=)" + whitespace +
1096  // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
1097  "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
1098  "*\\]",
1099
1100 pseudos = ":(" + characterEncoding + ")(?:\\((" +
1101  // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
1102  // 1. quoted (capture 3; capture 4 or capture 5)
1103  "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
1104  // 2. simple (capture 6)
1105  "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
1106  // 3. anything else (capture 2)
1107  ".*" +
1108  ")\\)|)",
1109
1110 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
1111 rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
1112
1113 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
1114 rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
1115
1116 rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
1117
1118 rpseudo = new RegExp( pseudos ),
1119 ridentifier = new RegExp( "^" + identifier + "$" ),
1120
1121 matchExpr = {
1122  "ID": new RegExp( "^#(" + characterEncoding + ")" ),
1123  "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
1124  "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
1125  "ATTR": new RegExp( "^" + attributes ),
1126  "PSEUDO": new RegExp( "^" + pseudos ),
1127  "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
1128   "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
1129   "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
1130  "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
1131  // For use in libraries implementing .is()
1132  // We use this for POS matching in `select`
1133  "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
1134   whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
1135 },
1136
1137 rinputs = /^(?:input|select|textarea|button)$/i,
1138 rheader = /^h\d$/i,
1139
1140 rnative = /^[^{]+\{\s*\[native \w/,
1141
1142 // Easily-parseable/retrievable ID or TAG or CLASS selectors
1143 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
1144
1145 rsibling = /[+~]/,
1146 rescape = /'|\\/g,
1147
1148 // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
1149 runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
1150 funescape = function( _, escaped, escapedWhitespace ) {
1151  var high = "0x" + escaped - 0x10000;
1152  // NaN means non-codepoint
1153  // Support: Firefox<24
1154  // Workaround erroneous numeric interpretation of +"0x"
1155  return high !== high || escapedWhitespace ?
1156   escaped :
1157   high < 0 ?
1158    // BMP codepoint
1159    String.fromCharCode( high + 0x10000 ) :
1160    // Supplemental Plane codepoint (surrogate pair)
1161    String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1162 };
1163
1164// Optimize for push.apply( _, NodeList )
1165try {
1166 push.apply(
1167  (arr = slice.call( preferredDoc.childNodes )),
1168  preferredDoc.childNodes
1169 );
1170 // Support: Android<4.0
1171 // Detect silently failing push.apply
1172 arr[ preferredDoc.childNodes.length ].nodeType;
1173} catch ( e ) {
1174 push = { apply: arr.length ?
1175
1176  // Leverage slice if possible
1177  function( target, els ) {
1178   push_native.apply( target, slice.call(els) );
1179  } :
1180
1181  // Support: IE<9
1182  // Otherwise append directly
1183  function( target, els ) {
1184   var j = target.length,
1185    i = 0;
1186   // Can't trust NodeList.length
1187   while ( (target[j++] = els[i++]) ) {}
1188   target.length = j - 1;
1189  }
1190 };
1191}
1192
1193function Sizzle( selector, context, results, seed ) {
1194 var match, elem, m, nodeType,
1195  // QSA vars
1196  i, groups, old, nid, newContext, newSelector;
1197
1198 if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
1199  setDocument( context );
1200 }
1201
1202 context = context || document;
1203 results = results || [];
1204
1205 if ( !selector || typeof selector !== "string" ) {
1206  return results;
1207 }
1208
1209 if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
1210  return [];
1211 }
1212
1213 if ( documentIsHTML && !seed ) {
1214
1215  // Shortcuts
1216  if ( (match = rquickExpr.exec( selector )) ) {
1217   // Speed-up: Sizzle("#ID")
1218   if ( (m = match[1]) ) {
1219    if ( nodeType === 9 ) {
1220     elem = context.getElementById( m );
1221     // Check parentNode to catch when Blackberry 4.6 returns
1222     // nodes that are no longer in the document (jQuery #6963)
1223     if ( elem && elem.parentNode ) {
1224      // Handle the case where IE, Opera, and Webkit return items
1225      // by name instead of ID
1226      if ( elem.id === m ) {
1227       results.push( elem );
1228       return results;
1229      }
1230     } else {
1231      return results;
1232     }
1233    } else {
1234     // Context is not a document
1235     if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
1236      contains( context, elem ) && elem.id === m ) {
1237      results.push( elem );
1238      return results;
1239     }
1240    }
1241
1242   // Speed-up: Sizzle("TAG")
1243   } else if ( match[2] ) {
1244    push.apply( results, context.getElementsByTagName( selector ) );
1245    return results;
1246
1247   // Speed-up: Sizzle(".CLASS")
1248   } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {
1249    push.apply( results, context.getElementsByClassName( m ) );
1250    return results;
1251   }
1252  }
1253
1254  // QSA path
1255  if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
1256   nid = old = expando;
1257   newContext = context;
1258   newSelector = nodeType === 9 && selector;
1259
1260   // qSA works strangely on Element-rooted queries
1261   // We can work around this by specifying an extra ID on the root
1262   // and working up from there (Thanks to Andrew Dupont for the technique)
1263   // IE 8 doesn't work on object elements
1264   if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
1265    groups = tokenize( selector );
1266
1267    if ( (old = context.getAttribute("id")) ) {
1268     nid = old.replace( rescape, "\\$&" );
1269    } else {
1270     context.setAttribute( "id", nid );
1271    }
1272    nid = "[id='" + nid + "'] ";
1273
1274    i = groups.length;
1275    while ( i-- ) {
1276     groups[i] = nid + toSelector( groups[i] );
1277    }
1278    newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
1279    newSelector = groups.join(",");
1280   }
1281
1282   if ( newSelector ) {
1283    try {
1284     push.apply( results,
1285      newContext.querySelectorAll( newSelector )
1286     );
1287     return results;
1288    } catch(qsaError) {
1289    } finally {
1290     if ( !old ) {
1291      context.removeAttribute("id");
1292     }
1293    }
1294   }
1295  }
1296 }
1297
1298 // All others
1299 return select( selector.replace( rtrim, "$1" ), context, results, seed );
1300}
1301
1302/**
1303 * Create key-value caches of limited size
1304 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
1305 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1306 * deleting the oldest entry
1307 */
1308function createCache() {
1309 var keys = [];
1310
1311 function cache( key, value ) {
1312  // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1313  if ( keys.push( key + " " ) > Expr.cacheLength ) {
1314   // Only keep the most recent entries
1315   delete cache[ keys.shift() ];
1316  }
1317  return (cache[ key + " " ] = value);
1318 }
1319 return cache;
1320}
1321
1322/**
1323 * Mark a function for special use by Sizzle
1324 * @param {Function} fn The function to mark
1325 */
1326function markFunction( fn ) {
1327 fn[ expando ] = true;
1328 return fn;
1329}
1330
1331/**
1332 * Support testing using an element
1333 * @param {Function} fn Passed the created div and expects a boolean result
1334 */
1335function assert( fn ) {
1336 var div = document.createElement("div");
1337
1338 try {
1339  return !!fn( div );
1340 } catch (e) {
1341  return false;
1342 } finally {
1343  // Remove from its parent by default
1344  if ( div.parentNode ) {
1345   div.parentNode.removeChild( div );
1346  }
1347  // release memory in IE
1348  div = null;
1349 }
1350}
1351
1352/**
1353 * Adds the same handler for all of the specified attrs
1354 * @param {String} attrs Pipe-separated list of attributes
1355 * @param {Function} handler The method that will be applied
1356 */
1357function addHandle( attrs, handler ) {
1358 var arr = attrs.split("|"),
1359  i = attrs.length;
1360
1361 while ( i-- ) {
1362  Expr.attrHandle[ arr[i] ] = handler;
1363 }
1364}
1365
1366/**
1367 * Checks document order of two siblings
1368 * @param {Element} a
1369 * @param {Element} b
1370 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1371 */
1372function siblingCheck( a, b ) {
1373 var cur = b && a,
1374  diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1375   ( ~b.sourceIndex || MAX_NEGATIVE ) -
1376   ( ~a.sourceIndex || MAX_NEGATIVE );
1377
1378 // Use IE sourceIndex if available on both nodes
1379 if ( diff ) {
1380  return diff;
1381 }
1382
1383 // Check if b follows a
1384 if ( cur ) {
1385  while ( (cur = cur.nextSibling) ) {
1386   if ( cur === b ) {
1387    return -1;
1388   }
1389  }
1390 }
1391
1392 return a ? 1 : -1;
1393}
1394
1395/**
1396 * Returns a function to use in pseudos for input types
1397 * @param {String} type
1398 */
1399function createInputPseudo( type ) {
1400 return function( elem ) {
1401  var name = elem.nodeName.toLowerCase();
1402  return name === "input" && elem.type === type;
1403 };
1404}
1405
1406/**
1407 * Returns a function to use in pseudos for buttons
1408 * @param {String} type
1409 */
1410function createButtonPseudo( type ) {
1411 return function( elem ) {
1412  var name = elem.nodeName.toLowerCase();
1413  return (name === "input" || name === "button") && elem.type === type;
1414 };
1415}
1416
1417/**
1418 * Returns a function to use in pseudos for positionals
1419 * @param {Function} fn
1420 */
1421function createPositionalPseudo( fn ) {
1422 return markFunction(function( argument ) {
1423  argument = +argument;
1424  return markFunction(function( seed, matches ) {
1425   var j,
1426    matchIndexes = fn( [], seed.length, argument ),
1427    i = matchIndexes.length;
1428
1429   // Match elements found at the specified indexes
1430   while ( i-- ) {
1431    if ( seed[ (j = matchIndexes[i]) ] ) {
1432     seed[j] = !(matches[j] = seed[j]);
1433    }
1434   }
1435  });
1436 });
1437}
1438
1439/**
1440 * Checks a node for validity as a Sizzle context
1441 * @param {Element|Object=} context
1442 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1443 */
1444function testContext( context ) {
1445 return context && typeof context.getElementsByTagName !== strundefined && context;
1446}
1447
1448// Expose support vars for convenience
1449support = Sizzle.support = {};
1450
1451/**
1452 * Detects XML nodes
1453 * @param {Element|Object} elem An element or a document
1454 * @returns {Boolean} True iff elem is a non-HTML XML node
1455 */
1456isXML = Sizzle.isXML = function( elem ) {
1457 // documentElement is verified for cases where it doesn't yet exist
1458 // (such as loading iframes in IE - #4833)
1459 var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1460 return documentElement ? documentElement.nodeName !== "HTML" : false;
1461};
1462
1463/**
1464 * Sets document-related variables once based on the current document
1465 * @param {Element|Object} [doc] An element or document object to use to set the document
1466 * @returns {Object} Returns the current document
1467 */
1468setDocument = Sizzle.setDocument = function( node ) {
1469 var hasCompare,
1470  doc = node ? node.ownerDocument || node : preferredDoc,
1471  parent = doc.defaultView;
1472
1473 // If no document and documentElement is available, return
1474 if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1475  return document;
1476 }
1477
1478 // Set our document
1479 document = doc;
1480 docElem = doc.documentElement;
1481
1482 // Support tests
1483 documentIsHTML = !isXML( doc );
1484
1485 // Support: IE>8
1486 // If iframe document is assigned to "document" variable and if iframe has been reloaded,
1487 // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1488 // IE6-8 do not support the defaultView property so parent will be undefined
1489 if ( parent && parent !== parent.top ) {
1490  // IE11 does not have attachEvent, so all must suffer
1491  if ( parent.addEventListener ) {
1492   parent.addEventListener( "unload", function() {
1493    setDocument();
1494   }, false );
1495  } else if ( parent.attachEvent ) {
1496   parent.attachEvent( "onunload", function() {
1497    setDocument();
1498   });
1499  }
1500 }
1501
1502 /* Attributes
1503 ---------------------------------------------------------------------- */
1504
1505 // Support: IE<8
1506 // Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
1507 support.attributes = assert(function( div ) {
1508  div.className = "i";
1509  return !div.getAttribute("className");
1510 });
1511
1512 /* getElement(s)By*
1513 ---------------------------------------------------------------------- */
1514
1515 // Check if getElementsByTagName("*") returns only elements
1516 support.getElementsByTagName = assert(function( div ) {
1517  div.appendChild( doc.createComment("") );
1518  return !div.getElementsByTagName("*").length;
1519 });
1520
1521 // Check if getElementsByClassName can be trusted
1522 support.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) {
1523  div.innerHTML = "<div class='a'></div><div class='a i'></div>";
1524
1525  // Support: Safari<4
1526  // Catch class over-caching
1527  div.firstChild.className = "i";
1528  // Support: Opera<10
1529  // Catch gEBCN failure to find non-leading classes
1530  return div.getElementsByClassName("i").length === 2;
1531 });
1532
1533 // Support: IE<10
1534 // Check if getElementById returns elements by name
1535 // The broken getElementById methods don't pick up programatically-set names,
1536 // so use a roundabout getElementsByName test
1537 support.getById = assert(function( div ) {
1538  docElem.appendChild( div ).id = expando;
1539  return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
1540 });
1541
1542 // ID find and filter
1543 if ( support.getById ) {
1544  Expr.find["ID"] = function( id, context ) {
1545   if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
1546    var m = context.getElementById( id );
1547    // Check parentNode to catch when Blackberry 4.6 returns
1548    // nodes that are no longer in the document #6963
1549    return m && m.parentNode ? [ m ] : [];
1550   }
1551  };
1552  Expr.filter["ID"] = function( id ) {
1553   var attrId = id.replace( runescape, funescape );
1554   return function( elem ) {
1555    return elem.getAttribute("id") === attrId;
1556   };
1557  };
1558 } else {
1559  // Support: IE6/7
1560  // getElementById is not reliable as a find shortcut
1561  delete Expr.find["ID"];
1562
1563  Expr.filter["ID"] =  function( id ) {
1564   var attrId = id.replace( runescape, funescape );
1565   return function( elem ) {
1566    var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1567    return node && node.value === attrId;
1568   };
1569  };
1570 }
1571
1572 // Tag
1573 Expr.find["TAG"] = support.getElementsByTagName ?
1574  function( tag, context ) {
1575   if ( typeof context.getElementsByTagName !== strundefined ) {
1576    return context.getElementsByTagName( tag );
1577   }
1578  } :
1579  function( tag, context ) {
1580   var elem,
1581    tmp = [],
1582    i = 0,
1583    results = context.getElementsByTagName( tag );
1584
1585   // Filter out possible comments
1586   if ( tag === "*" ) {
1587    while ( (elem = results[i++]) ) {
1588     if ( elem.nodeType === 1 ) {
1589      tmp.push( elem );
1590     }
1591    }
1592
1593    return tmp;
1594   }
1595   return results;
1596  };
1597
1598 // Class
1599 Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1600  if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1601   return context.getElementsByClassName( className );
1602  }
1603 };
1604
1605 /* QSA/matchesSelector
1606 ---------------------------------------------------------------------- */
1607
1608 // QSA and matchesSelector support
1609
1610 // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1611 rbuggyMatches = [];
1612
1613 // qSa(:focus) reports false when true (Chrome 21)
1614 // We allow this because of a bug in IE8/9 that throws an error
1615 // whenever `document.activeElement` is accessed on an iframe
1616 // So, we allow :focus to pass through QSA all the time to avoid the IE error
1617 // See http://bugs.jquery.com/ticket/13378
1618 rbuggyQSA = [];
1619
1620 if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1621  // Build QSA regex
1622  // Regex strategy adopted from Diego Perini
1623  assert(function( div ) {
1624   // Select is set to empty string on purpose
1625   // This is to test IE's treatment of not explicitly
1626   // setting a boolean content attribute,
1627   // since its presence should be enough
1628   // http://bugs.jquery.com/ticket/12359
1629   div.innerHTML = "<select msallowclip=''><option selected=''></option></select>";
1630
1631   // Support: IE8, Opera 11-12.16
1632   // Nothing should be selected when empty strings follow ^= or $= or *=
1633   // The test attribute must be unknown in Opera but "safe" for WinRT
1634   // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1635   if ( div.querySelectorAll("[msallowclip^='']").length ) {
1636    rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1637   }
1638
1639   // Support: IE8
1640   // Boolean attributes and "value" are not treated correctly
1641   if ( !div.querySelectorAll("[selected]").length ) {
1642    rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1643   }
1644
1645   // Webkit/Opera - :checked should return selected option elements
1646   // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1647   // IE8 throws error here and will not see later tests
1648   if ( !div.querySelectorAll(":checked").length ) {
1649    rbuggyQSA.push(":checked");
1650   }
1651  });
1652
1653  assert(function( div ) {
1654   // Support: Windows 8 Native Apps
1655   // The type and name attributes are restricted during .innerHTML assignment
1656   var input = doc.createElement("input");
1657   input.setAttribute( "type", "hidden" );
1658   div.appendChild( input ).setAttribute( "name", "D" );
1659
1660   // Support: IE8
1661   // Enforce case-sensitivity of name attribute
1662   if ( div.querySelectorAll("[name=d]").length ) {
1663    rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1664   }
1665
1666   // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1667   // IE8 throws error here and will not see later tests
1668   if ( !div.querySelectorAll(":enabled").length ) {
1669    rbuggyQSA.push( ":enabled", ":disabled" );
1670   }
1671
1672   // Opera 10-11 does not throw on post-comma invalid pseudos
1673   div.querySelectorAll("*,:x");
1674   rbuggyQSA.push(",.*:");
1675  });
1676 }
1677
1678 if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1679  docElem.webkitMatchesSelector ||
1680  docElem.mozMatchesSelector ||
1681  docElem.oMatchesSelector ||
1682  docElem.msMatchesSelector) )) ) {
1683
1684  assert(function( div ) {
1685   // Check to see if it's possible to do matchesSelector
1686   // on a disconnected node (IE 9)
1687   support.disconnectedMatch = matches.call( div, "div" );
1688
1689   // This should fail with an exception
1690   // Gecko does not error, returns false instead
1691   matches.call( div, "[s!='']:x" );
1692   rbuggyMatches.push( "!=", pseudos );
1693  });
1694 }
1695
1696 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1697 rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1698
1699 /* Contains
1700 ---------------------------------------------------------------------- */
1701 hasCompare = rnative.test( docElem.compareDocumentPosition );
1702
1703 // Element contains another
1704 // Purposefully does not implement inclusive descendent
1705 // As in, an element does not contain itself
1706 contains = hasCompare || rnative.test( docElem.contains ) ?
1707  function( a, b ) {
1708   var adown = a.nodeType === 9 ? a.documentElement : a,
1709    bup = b && b.parentNode;
1710   return a === bup || !!( bup && bup.nodeType === 1 && (
1711    adown.contains ?
1712     adown.contains( bup ) :
1713     a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1714   ));
1715  } :
1716  function( a, b ) {
1717   if ( b ) {
1718    while ( (b = b.parentNode) ) {
1719     if ( b === a ) {
1720      return true;
1721     }
1722    }
1723   }
1724   return false;
1725  };
1726
1727 /* Sorting
1728 ---------------------------------------------------------------------- */
1729
1730 // Document order sorting
1731 sortOrder = hasCompare ?
1732 function( a, b ) {
1733
1734  // Flag for duplicate removal
1735  if ( a === b ) {
1736   hasDuplicate = true;
1737   return 0;
1738  }
1739
1740  // Sort on method existence if only one input has compareDocumentPosition
1741  var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1742  if ( compare ) {
1743   return compare;
1744  }
1745
1746  // Calculate position if both inputs belong to the same document
1747  compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1748   a.compareDocumentPosition( b ) :
1749
1750   // Otherwise we know they are disconnected
1751   1;
1752
1753  // Disconnected nodes
1754  if ( compare & 1 ||
1755   (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1756
1757   // Choose the first element that is related to our preferred document
1758   if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1759    return -1;
1760   }
1761   if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1762    return 1;
1763   }
1764
1765   // Maintain original order
1766   return sortInput ?
1767    ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1768    0;
1769  }
1770
1771  return compare & 4 ? -1 : 1;
1772 } :
1773 function( a, b ) {
1774  // Exit early if the nodes are identical
1775  if ( a === b ) {
1776   hasDuplicate = true;
1777   return 0;
1778  }
1779
1780  var cur,
1781   i = 0,
1782   aup = a.parentNode,
1783   bup = b.parentNode,
1784   ap = [ a ],
1785   bp = [ b ];
1786
1787  // Parentless nodes are either documents or disconnected
1788  if ( !aup || !bup ) {
1789   return a === doc ? -1 :
1790    b === doc ? 1 :
1791    aup ? -1 :
1792    bup ? 1 :
1793    sortInput ?
1794    ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1795    0;
1796
1797  // If the nodes are siblings, we can do a quick check
1798  } else if ( aup === bup ) {
1799   return siblingCheck( a, b );
1800  }
1801
1802  // Otherwise we need full lists of their ancestors for comparison
1803  cur = a;
1804  while ( (cur = cur.parentNode) ) {
1805   ap.unshift( cur );
1806  }
1807  cur = b;
1808  while ( (cur = cur.parentNode) ) {
1809   bp.unshift( cur );
1810  }
1811
1812  // Walk down the tree looking for a discrepancy
1813  while ( ap[i] === bp[i] ) {
1814   i++;
1815  }
1816
1817  return i ?
1818   // Do a sibling check if the nodes have a common ancestor
1819   siblingCheck( ap[i], bp[i] ) :
1820
1821   // Otherwise nodes in our document sort first
1822   ap[i] === preferredDoc ? -1 :
1823   bp[i] === preferredDoc ? 1 :
1824   0;
1825 };
1826
1827 return doc;
1828};
1829
1830Sizzle.matches = function( expr, elements ) {
1831 return Sizzle( expr, null, null, elements );
1832};
1833
1834Sizzle.matchesSelector = function( elem, expr ) {
1835 // Set document vars if needed
1836 if ( ( elem.ownerDocument || elem ) !== document ) {
1837  setDocument( elem );
1838 }
1839
1840 // Make sure that attribute selectors are quoted
1841 expr = expr.replace( rattributeQuotes, "='$1']" );
1842
1843 if ( support.matchesSelector && documentIsHTML &&
1844  ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1845  ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1846
1847  try {
1848   var ret = matches.call( elem, expr );
1849
1850   // IE 9's matchesSelector returns false on disconnected nodes
1851   if ( ret || support.disconnectedMatch ||
1852     // As well, disconnected nodes are said to be in a document
1853     // fragment in IE 9
1854     elem.document && elem.document.nodeType !== 11 ) {
1855    return ret;
1856   }
1857  } catch(e) {}
1858 }
1859
1860 return Sizzle( expr, document, null, [ elem ] ).length > 0;
1861};
1862
1863Sizzle.contains = function( context, elem ) {
1864 // Set document vars if needed
1865 if ( ( context.ownerDocument || context ) !== document ) {
1866  setDocument( context );
1867 }
1868 return contains( context, elem );
1869};
1870
1871Sizzle.attr = function( elem, name ) {
1872 // Set document vars if needed
1873 if ( ( elem.ownerDocument || elem ) !== document ) {
1874  setDocument( elem );
1875 }
1876
1877 var fn = Expr.attrHandle[ name.toLowerCase() ],
1878  // Don't get fooled by Object.prototype properties (jQuery #13807)
1879  val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1880   fn( elem, name, !documentIsHTML ) :
1881   undefined;
1882
1883 return val !== undefined ?
1884  val :
1885  support.attributes || !documentIsHTML ?
1886   elem.getAttribute( name ) :
1887   (val = elem.getAttributeNode(name)) && val.specified ?
1888    val.value :
1889    null;
1890};
1891
1892Sizzle.error = function( msg ) {
1893 throw new Error( "Syntax error, unrecognized expression: " + msg );
1894};
1895
1896/**
1897 * Document sorting and removing duplicates
1898 * @param {ArrayLike} results
1899 */
1900Sizzle.uniqueSort = function( results ) {
1901 var elem,
1902  duplicates = [],
1903  j = 0,
1904  i = 0;
1905
1906 // Unless we *know* we can detect duplicates, assume their presence
1907 hasDuplicate = !support.detectDuplicates;
1908 sortInput = !support.sortStable && results.slice( 0 );
1909 results.sort( sortOrder );
1910
1911 if ( hasDuplicate ) {
1912  while ( (elem = results[i++]) ) {
1913   if ( elem === results[ i ] ) {
1914    j = duplicates.push( i );
1915   }
1916  }
1917  while ( j-- ) {
1918   results.splice( duplicates[ j ], 1 );
1919  }
1920 }
1921
1922 // Clear input after sorting to release objects
1923 // See https://github.com/jquery/sizzle/pull/225
1924 sortInput = null;
1925
1926 return results;
1927};
1928
1929/**
1930 * Utility function for retrieving the text value of an array of DOM nodes
1931 * @param {Array|Element} elem
1932 */
1933getText = Sizzle.getText = function( elem ) {
1934 var node,
1935  ret = "",
1936  i = 0,
1937  nodeType = elem.nodeType;
1938
1939 if ( !nodeType ) {
1940  // If no nodeType, this is expected to be an array
1941  while ( (node = elem[i++]) ) {
1942   // Do not traverse comment nodes
1943   ret += getText( node );
1944  }
1945 } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1946  // Use textContent for elements
1947  // innerText usage removed for consistency of new lines (jQuery #11153)
1948  if ( typeof elem.textContent === "string" ) {
1949   return elem.textContent;
1950  } else {
1951   // Traverse its children
1952   for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1953    ret += getText( elem );
1954   }
1955  }
1956 } else if ( nodeType === 3 || nodeType === 4 ) {
1957  return elem.nodeValue;
1958 }
1959 // Do not include comment or processing instruction nodes
1960
1961 return ret;
1962};
1963
1964Expr = Sizzle.selectors = {
1965
1966 // Can be adjusted by the user
1967 cacheLength: 50,
1968
1969 createPseudo: markFunction,
1970
1971 match: matchExpr,
1972
1973 attrHandle: {},
1974
1975 find: {},
1976
1977 relative: {
1978  ">": { dir: "parentNode", first: true },
1979  " ": { dir: "parentNode" },
1980  "+": { dir: "previousSibling", first: true },
1981  "~": { dir: "previousSibling" }
1982 },
1983
1984 preFilter: {
1985  "ATTR": function( match ) {
1986   match[1] = match[1].replace( runescape, funescape );
1987
1988   // Move the given value to match[3] whether quoted or unquoted
1989   match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1990
1991   if ( match[2] === "~=" ) {
1992    match[3] = " " + match[3] + " ";
1993   }
1994
1995   return match.slice( 0, 4 );
1996  },
1997
1998  "CHILD": function( match ) {
1999   /* matches from matchExpr["CHILD"]
2000    1 type (only|nth|...)
2001    2 what (child|of-type)
2002    3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
2003    4 xn-component of xn+y argument ([+-]?\d*n|)
2004    5 sign of xn-component
2005    6 x of xn-component
2006    7 sign of y-component
2007    8 y of y-component
2008   */
2009   match[1] = match[1].toLowerCase();
2010
2011   if ( match[1].slice( 0, 3 ) === "nth" ) {
2012    // nth-* requires argument
2013    if ( !match[3] ) {
2014     Sizzle.error( match[0] );
2015    }
2016
2017    // numeric x and y parameters for Expr.filter.CHILD
2018    // remember that false/true cast respectively to 0/1
2019    match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
2020    match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
2021
2022   // other types prohibit arguments
2023   } else if ( match[3] ) {
2024    Sizzle.error( match[0] );
2025   }
2026
2027   return match;
2028  },
2029
2030  "PSEUDO": function( match ) {
2031   var excess,
2032    unquoted = !match[6] && match[2];
2033
2034   if ( matchExpr["CHILD"].test( match[0] ) ) {
2035    return null;
2036   }
2037
2038   // Accept quoted arguments as-is
2039   if ( match[3] ) {
2040    match[2] = match[4] || match[5] || "";
2041
2042   // Strip excess characters from unquoted arguments
2043   } else if ( unquoted && rpseudo.test( unquoted ) &&
2044    // Get excess from tokenize (recursively)
2045    (excess = tokenize( unquoted, true )) &&
2046    // advance to the next closing parenthesis
2047    (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
2048
2049    // excess is a negative index
2050    match[0] = match[0].slice( 0, excess );
2051    match[2] = unquoted.slice( 0, excess );
2052   }
2053
2054   // Return only captures needed by the pseudo filter method (type and argument)
2055   return match.slice( 0, 3 );
2056  }
2057 },
2058
2059 filter: {
2060
2061  "TAG": function( nodeNameSelector ) {
2062   var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
2063   return nodeNameSelector === "*" ?
2064    function() { return true; } :
2065    function( elem ) {
2066     return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
2067    };
2068  },
2069
2070  "CLASS": function( className ) {
2071   var pattern = classCache[ className + " " ];
2072
2073   return pattern ||
2074    (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
2075    classCache( className, function( elem ) {
2076     return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
2077    });
2078  },
2079
2080  "ATTR": function( name, operator, check ) {
2081   return function( elem ) {
2082    var result = Sizzle.attr( elem, name );
2083
2084    if ( result == null ) {
2085     return operator === "!=";
2086    }
2087    if ( !operator ) {
2088     return true;
2089    }
2090
2091    result += "";
2092
2093    return operator === "=" ? result === check :
2094     operator === "!=" ? result !== check :
2095     operator === "^=" ? check && result.indexOf( check ) === 0 :
2096     operator === "*=" ? check && result.indexOf( check ) > -1 :
2097     operator === "$=" ? check && result.slice( -check.length ) === check :
2098     operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
2099     operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
2100     false;
2101   };
2102  },
2103
2104  "CHILD": function( type, what, argument, first, last ) {
2105   var simple = type.slice( 0, 3 ) !== "nth",
2106    forward = type.slice( -4 ) !== "last",
2107    ofType = what === "of-type";
2108
2109   return first === 1 && last === 0 ?
2110
2111    // Shortcut for :nth-*(n)
2112    function( elem ) {
2113     return !!elem.parentNode;
2114    } :
2115
2116    function( elem, context, xml ) {
2117     var cache, outerCache, node, diff, nodeIndex, start,
2118      dir = simple !== forward ? "nextSibling" : "previousSibling",
2119      parent = elem.parentNode,
2120      name = ofType && elem.nodeName.toLowerCase(),
2121      useCache = !xml && !ofType;
2122
2123     if ( parent ) {
2124
2125      // :(first|last|only)-(child|of-type)
2126      if ( simple ) {
2127       while ( dir ) {
2128        node = elem;
2129        while ( (node = node[ dir ]) ) {
2130         if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
2131          return false;
2132         }
2133        }
2134        // Reverse direction for :only-* (if we haven't yet done so)
2135        start = dir = type === "only" && !start && "nextSibling";
2136       }
2137       return true;
2138      }
2139
2140      start = [ forward ? parent.firstChild : parent.lastChild ];
2141
2142      // non-xml :nth-child(...) stores cache data on `parent`
2143      if ( forward && useCache ) {
2144       // Seek `elem` from a previously-cached index
2145       outerCache = parent[ expando ] || (parent[ expando ] = {});
2146       cache = outerCache[ type ] || [];
2147       nodeIndex = cache[0] === dirruns && cache[1];
2148       diff = cache[0] === dirruns && cache[2];
2149       node = nodeIndex && parent.childNodes[ nodeIndex ];
2150
2151       while ( (node = ++nodeIndex && node && node[ dir ] ||
2152
2153        // Fallback to seeking `elem` from the start
2154        (diff = nodeIndex = 0) || start.pop()) ) {
2155
2156        // When found, cache indexes on `parent` and break
2157        if ( node.nodeType === 1 && ++diff && node === elem ) {
2158         outerCache[ type ] = [ dirruns, nodeIndex, diff ];
2159         break;
2160        }
2161       }
2162
2163      // Use previously-cached element index if available
2164      } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
2165       diff = cache[1];
2166
2167      // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
2168      } else {
2169       // Use the same loop as above to seek `elem` from the start
2170       while ( (node = ++nodeIndex && node && node[ dir ] ||
2171        (diff = nodeIndex = 0) || start.pop()) ) {
2172
2173        if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
2174         // Cache the index of each encountered element
2175         if ( useCache ) {
2176          (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
2177         }
2178
2179         if ( node === elem ) {
2180          break;
2181         }
2182        }
2183       }
2184      }
2185
2186      // Incorporate the offset, then check against cycle size
2187      diff -= last;
2188      return diff === first || ( diff % first === 0 && diff / first >= 0 );
2189     }
2190    };
2191  },
2192
2193  "PSEUDO": function( pseudo, argument ) {
2194   // pseudo-class names are case-insensitive
2195   // http://www.w3.org/TR/selectors/#pseudo-classes
2196   // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2197   // Remember that setFilters inherits from pseudos
2198   var args,
2199    fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2200     Sizzle.error( "unsupported pseudo: " + pseudo );
2201
2202   // The user may use createPseudo to indicate that
2203   // arguments are needed to create the filter function
2204   // just as Sizzle does
2205   if ( fn[ expando ] ) {
2206    return fn( argument );
2207   }
2208
2209   // But maintain support for old signatures
2210   if ( fn.length > 1 ) {
2211    args = [ pseudo, pseudo, "", argument ];
2212    return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2213     markFunction(function( seed, matches ) {
2214      var idx,
2215       matched = fn( seed, argument ),
2216       i = matched.length;
2217      while ( i-- ) {
2218       idx = indexOf.call( seed, matched[i] );
2219       seed[ idx ] = !( matches[ idx ] = matched[i] );
2220      }
2221     }) :
2222     function( elem ) {
2223      return fn( elem, 0, args );
2224     };
2225   }
2226
2227   return fn;
2228  }
2229 },
2230
2231 pseudos: {
2232  // Potentially complex pseudos
2233  "not": markFunction(function( selector ) {
2234   // Trim the selector passed to compile
2235   // to avoid treating leading and trailing
2236   // spaces as combinators
2237   var input = [],
2238    results = [],
2239    matcher = compile( selector.replace( rtrim, "$1" ) );
2240
2241   return matcher[ expando ] ?
2242    markFunction(function( seed, matches, context, xml ) {
2243     var elem,
2244      unmatched = matcher( seed, null, xml, [] ),
2245      i = seed.length;
2246
2247     // Match elements unmatched by `matcher`
2248     while ( i-- ) {
2249      if ( (elem = unmatched[i]) ) {
2250       seed[i] = !(matches[i] = elem);
2251      }
2252     }
2253    }) :
2254    function( elem, context, xml ) {
2255     input[0] = elem;
2256     matcher( input, null, xml, results );
2257     return !results.pop();
2258    };
2259  }),
2260
2261  "has": markFunction(function( selector ) {
2262   return function( elem ) {
2263    return Sizzle( selector, elem ).length > 0;
2264   };
2265  }),
2266
2267  "contains": markFunction(function( text ) {
2268   return function( elem ) {
2269    return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2270   };
2271  }),
2272
2273  // "Whether an element is represented by a :lang() selector
2274  // is based solely on the element's language value
2275  // being equal to the identifier C,
2276  // or beginning with the identifier C immediately followed by "-".
2277  // The matching of C against the element's language value is performed case-insensitively.
2278  // The identifier C does not have to be a valid language name."
2279  // http://www.w3.org/TR/selectors/#lang-pseudo
2280  "lang": markFunction( function( lang ) {
2281   // lang value must be a valid identifier
2282   if ( !ridentifier.test(lang || "") ) {
2283    Sizzle.error( "unsupported lang: " + lang );
2284   }
2285   lang = lang.replace( runescape, funescape ).toLowerCase();
2286   return function( elem ) {
2287    var elemLang;
2288    do {
2289     if ( (elemLang = documentIsHTML ?
2290      elem.lang :
2291      elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2292
2293      elemLang = elemLang.toLowerCase();
2294      return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2295     }
2296    } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2297    return false;
2298   };
2299  }),
2300
2301  // Miscellaneous
2302  "target": function( elem ) {
2303   var hash = window.location && window.location.hash;
2304   return hash && hash.slice( 1 ) === elem.id;
2305  },
2306
2307  "root": function( elem ) {
2308   return elem === docElem;
2309  },
2310
2311  "focus": function( elem ) {
2312   return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2313  },
2314
2315  // Boolean properties
2316  "enabled": function( elem ) {
2317   return elem.disabled === false;
2318  },
2319
2320  "disabled": function( elem ) {
2321   return elem.disabled === true;
2322  },
2323
2324  "checked": function( elem ) {
2325   // In CSS3, :checked should return both checked and selected elements
2326   // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2327   var nodeName = elem.nodeName.toLowerCase();
2328   return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2329  },
2330
2331  "selected": function( elem ) {
2332   // Accessing this property makes selected-by-default
2333   // options in Safari work properly
2334   if ( elem.parentNode ) {
2335    elem.parentNode.selectedIndex;
2336   }
2337
2338   return elem.selected === true;
2339  },
2340
2341  // Contents
2342  "empty": function( elem ) {
2343   // http://www.w3.org/TR/selectors/#empty-pseudo
2344   // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2345   //   but not by others (comment: 8; processing instruction: 7; etc.)
2346   // nodeType < 6 works because attributes (2) do not appear as children
2347   for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2348    if ( elem.nodeType < 6 ) {
2349     return false;
2350    }
2351   }
2352   return true;
2353  },
2354
2355  "parent": function( elem ) {
2356   return !Expr.pseudos["empty"]( elem );
2357  },
2358
2359  // Element/input types
2360  "header": function( elem ) {
2361   return rheader.test( elem.nodeName );
2362  },
2363
2364  "input": function( elem ) {
2365   return rinputs.test( elem.nodeName );
2366  },
2367
2368  "button": function( elem ) {
2369   var name = elem.nodeName.toLowerCase();
2370   return name === "input" && elem.type === "button" || name === "button";
2371  },
2372
2373  "text": function( elem ) {
2374   var attr;
2375   return elem.nodeName.toLowerCase() === "input" &&
2376    elem.type === "text" &&
2377
2378    // Support: IE<8
2379    // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2380    ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
2381  },
2382
2383  // Position-in-collection
2384  "first": createPositionalPseudo(function() {
2385   return [ 0 ];
2386  }),
2387
2388  "last": createPositionalPseudo(function( matchIndexes, length ) {
2389   return [ length - 1 ];
2390  }),
2391
2392  "eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2393   return [ argument < 0 ? argument + length : argument ];
2394  }),
2395
2396  "even": createPositionalPseudo(function( matchIndexes, length ) {
2397   var i = 0;
2398   for ( ; i < length; i += 2 ) {
2399    matchIndexes.push( i );
2400   }
2401   return matchIndexes;
2402  }),
2403
2404  "odd": createPositionalPseudo(function( matchIndexes, length ) {
2405   var i = 1;
2406   for ( ; i < length; i += 2 ) {
2407    matchIndexes.push( i );
2408   }
2409   return matchIndexes;
2410  }),
2411
2412  "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2413   var i = argument < 0 ? argument + length : argument;
2414   for ( ; --i >= 0; ) {
2415    matchIndexes.push( i );
2416   }
2417   return matchIndexes;
2418  }),
2419
2420  "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2421   var i = argument < 0 ? argument + length : argument;
2422   for ( ; ++i < length; ) {
2423    matchIndexes.push( i );
2424   }
2425   return matchIndexes;
2426  })
2427 }
2428};
2429
2430Expr.pseudos["nth"] = Expr.pseudos["eq"];
2431
2432// Add button/input type pseudos
2433for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2434 Expr.pseudos[ i ] = createInputPseudo( i );
2435}
2436for ( i in { submit: true, reset: true } ) {
2437 Expr.pseudos[ i ] = createButtonPseudo( i );
2438}
2439
2440// Easy API for creating new setFilters
2441function setFilters() {}
2442setFilters.prototype = Expr.filters = Expr.pseudos;
2443Expr.setFilters = new setFilters();
2444
2445tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2446 var matched, match, tokens, type,
2447  soFar, groups, preFilters,
2448  cached = tokenCache[ selector + " " ];
2449
2450 if ( cached ) {
2451  return parseOnly ? 0 : cached.slice( 0 );
2452 }
2453
2454 soFar = selector;
2455 groups = [];
2456 preFilters = Expr.preFilter;
2457
2458 while ( soFar ) {
2459
2460  // Comma and first run
2461  if ( !matched || (match = rcomma.exec( soFar )) ) {
2462   if ( match ) {
2463    // Don't consume trailing commas as valid
2464    soFar = soFar.slice( match[0].length ) || soFar;
2465   }
2466   groups.push( (tokens = []) );
2467  }
2468
2469  matched = false;
2470
2471  // Combinators
2472  if ( (match = rcombinators.exec( soFar )) ) {
2473   matched = match.shift();
2474   tokens.push({
2475    value: matched,
2476    // Cast descendant combinators to space
2477    type: match[0].replace( rtrim, " " )
2478   });
2479   soFar = soFar.slice( matched.length );
2480  }
2481
2482  // Filters
2483  for ( type in Expr.filter ) {
2484   if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2485    (match = preFilters[ type ]( match ))) ) {
2486    matched = match.shift();
2487    tokens.push({
2488     value: matched,
2489     type: type,
2490     matches: match
2491    });
2492    soFar = soFar.slice( matched.length );
2493   }
2494  }
2495
2496  if ( !matched ) {
2497   break;
2498  }
2499 }
2500
2501 // Return the length of the invalid excess
2502 // if we're just parsing
2503 // Otherwise, throw an error or return tokens
2504 return parseOnly ?
2505  soFar.length :
2506  soFar ?
2507   Sizzle.error( selector ) :
2508   // Cache the tokens
2509   tokenCache( selector, groups ).slice( 0 );
2510};
2511
2512function toSelector( tokens ) {
2513 var i = 0,
2514  len = tokens.length,
2515  selector = "";
2516 for ( ; i < len; i++ ) {
2517  selector += tokens[i].value;
2518 }
2519 return selector;
2520}
2521
2522function addCombinator( matcher, combinator, base ) {
2523 var dir = combinator.dir,
2524  checkNonElements = base && dir === "parentNode",
2525  doneName = done++;
2526
2527 return combinator.first ?
2528  // Check against closest ancestor/preceding element
2529  function( elem, context, xml ) {
2530   while ( (elem = elem[ dir ]) ) {
2531    if ( elem.nodeType === 1 || checkNonElements ) {
2532     return matcher( elem, context, xml );
2533    }
2534   }
2535  } :
2536
2537  // Check against all ancestor/preceding elements
2538  function( elem, context, xml ) {
2539   var oldCache, outerCache,
2540    newCache = [ dirruns, doneName ];
2541
2542   // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2543   if ( xml ) {
2544    while ( (elem = elem[ dir ]) ) {
2545     if ( elem.nodeType === 1 || checkNonElements ) {
2546      if ( matcher( elem, context, xml ) ) {
2547       return true;
2548      }
2549     }
2550    }
2551   } else {
2552    while ( (elem = elem[ dir ]) ) {
2553     if ( elem.nodeType === 1 || checkNonElements ) {
2554      outerCache = elem[ expando ] || (elem[ expando ] = {});
2555      if ( (oldCache = outerCache[ dir ]) &&
2556       oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2557
2558       // Assign to newCache so results back-propagate to previous elements
2559       return (newCache[ 2 ] = oldCache[ 2 ]);
2560      } else {
2561       // Reuse newcache so results back-propagate to previous elements
2562       outerCache[ dir ] = newCache;
2563
2564       // A match means we're done; a fail means we have to keep checking
2565       if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2566        return true;
2567       }
2568      }
2569     }
2570    }
2571   }
2572  };
2573}
2574
2575function elementMatcher( matchers ) {
2576 return matchers.length > 1 ?
2577  function( elem, context, xml ) {
2578   var i = matchers.length;
2579   while ( i-- ) {
2580    if ( !matchers[i]( elem, context, xml ) ) {
2581     return false;
2582    }
2583   }
2584   return true;
2585  } :
2586  matchers[0];
2587}
2588
2589function multipleContexts( selector, contexts, results ) {
2590 var i = 0,
2591  len = contexts.length;
2592 for ( ; i < len; i++ ) {
2593  Sizzle( selector, contexts[i], results );
2594 }
2595 return results;
2596}
2597
2598function condense( unmatched, map, filter, context, xml ) {
2599 var elem,
2600  newUnmatched = [],
2601  i = 0,
2602  len = unmatched.length,
2603  mapped = map != null;
2604
2605 for ( ; i < len; i++ ) {
2606  if ( (elem = unmatched[i]) ) {
2607   if ( !filter || filter( elem, context, xml ) ) {
2608    newUnmatched.push( elem );
2609    if ( mapped ) {
2610     map.push( i );
2611    }
2612   }
2613  }
2614 }
2615
2616 return newUnmatched;
2617}
2618
2619function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2620 if ( postFilter && !postFilter[ expando ] ) {
2621  postFilter = setMatcher( postFilter );
2622 }
2623 if ( postFinder && !postFinder[ expando ] ) {
2624  postFinder = setMatcher( postFinder, postSelector );
2625 }
2626 return markFunction(function( seed, results, context, xml ) {
2627  var temp, i, elem,
2628   preMap = [],
2629   postMap = [],
2630   preexisting = results.length,
2631
2632   // Get initial elements from seed or context
2633   elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2634
2635   // Prefilter to get matcher input, preserving a map for seed-results synchronization
2636   matcherIn = preFilter && ( seed || !selector ) ?
2637    condense( elems, preMap, preFilter, context, xml ) :
2638    elems,
2639
2640   matcherOut = matcher ?
2641    // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2642    postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2643
2644     // ...intermediate processing is necessary
2645     [] :
2646
2647     // ...otherwise use results directly
2648     results :
2649    matcherIn;
2650
2651  // Find primary matches
2652  if ( matcher ) {
2653   matcher( matcherIn, matcherOut, context, xml );
2654  }
2655
2656  // Apply postFilter
2657  if ( postFilter ) {
2658   temp = condense( matcherOut, postMap );
2659   postFilter( temp, [], context, xml );
2660
2661   // Un-match failing elements by moving them back to matcherIn
2662   i = temp.length;
2663   while ( i-- ) {
2664    if ( (elem = temp[i]) ) {
2665     matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2666    }
2667   }
2668  }
2669
2670  if ( seed ) {
2671   if ( postFinder || preFilter ) {
2672    if ( postFinder ) {
2673     // Get the final matcherOut by condensing this intermediate into postFinder contexts
2674     temp = [];
2675     i = matcherOut.length;
2676     while ( i-- ) {
2677      if ( (elem = matcherOut[i]) ) {
2678       // Restore matcherIn since elem is not yet a final match
2679       temp.push( (matcherIn[i] = elem) );
2680      }
2681     }
2682     postFinder( null, (matcherOut = []), temp, xml );
2683    }
2684
2685    // Move matched elements from seed to results to keep them synchronized
2686    i = matcherOut.length;
2687    while ( i-- ) {
2688     if ( (elem = matcherOut[i]) &&
2689      (temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2690
2691      seed[temp] = !(results[temp] = elem);
2692     }
2693    }
2694   }
2695
2696  // Add elements to results, through postFinder if defined
2697  } else {
2698   matcherOut = condense(
2699    matcherOut === results ?
2700     matcherOut.splice( preexisting, matcherOut.length ) :
2701     matcherOut
2702   );
2703   if ( postFinder ) {
2704    postFinder( null, results, matcherOut, xml );
2705   } else {
2706    push.apply( results, matcherOut );
2707   }
2708  }
2709 });
2710}
2711
2712function matcherFromTokens( tokens ) {
2713 var checkContext, matcher, j,
2714  len = tokens.length,
2715  leadingRelative = Expr.relative[ tokens[0].type ],
2716  implicitRelative = leadingRelative || Expr.relative[" "],
2717  i = leadingRelative ? 1 : 0,
2718
2719  // The foundational matcher ensures that elements are reachable from top-level context(s)
2720  matchContext = addCombinator( function( elem ) {
2721   return elem === checkContext;
2722  }, implicitRelative, true ),
2723  matchAnyContext = addCombinator( function( elem ) {
2724   return indexOf.call( checkContext, elem ) > -1;
2725  }, implicitRelative, true ),
2726  matchers = [ function( elem, context, xml ) {
2727   return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2728    (checkContext = context).nodeType ?
2729     matchContext( elem, context, xml ) :
2730     matchAnyContext( elem, context, xml ) );
2731  } ];
2732
2733 for ( ; i < len; i++ ) {
2734  if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2735   matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2736  } else {
2737   matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2738
2739   // Return special upon seeing a positional matcher
2740   if ( matcher[ expando ] ) {
2741    // Find the next relative operator (if any) for proper handling
2742    j = ++i;
2743    for ( ; j < len; j++ ) {
2744     if ( Expr.relative[ tokens[j].type ] ) {
2745      break;
2746     }
2747    }
2748    return setMatcher(
2749     i > 1 && elementMatcher( matchers ),
2750     i > 1 && toSelector(
2751      // If the preceding token was a descendant combinator, insert an implicit any-element `*`
2752      tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2753     ).replace( rtrim, "$1" ),
2754     matcher,
2755     i < j && matcherFromTokens( tokens.slice( i, j ) ),
2756     j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2757     j < len && toSelector( tokens )
2758    );
2759   }
2760   matchers.push( matcher );
2761  }
2762 }
2763
2764 return elementMatcher( matchers );
2765}
2766
2767function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2768 var bySet = setMatchers.length > 0,
2769  byElement = elementMatchers.length > 0,
2770  superMatcher = function( seed, context, xml, results, outermost ) {
2771   var elem, j, matcher,
2772    matchedCount = 0,
2773    i = "0",
2774    unmatched = seed && [],
2775    setMatched = [],
2776    contextBackup = outermostContext,
2777    // We must always have either seed elements or outermost context
2778    elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2779    // Use integer dirruns iff this is the outermost matcher
2780    dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2781    len = elems.length;
2782
2783   if ( outermost ) {
2784    outermostContext = context !== document && context;
2785   }
2786
2787   // Add elements passing elementMatchers directly to results
2788   // Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2789   // Support: IE<9, Safari
2790   // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2791   for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2792    if ( byElement && elem ) {
2793     j = 0;
2794     while ( (matcher = elementMatchers[j++]) ) {
2795      if ( matcher( elem, context, xml ) ) {
2796       results.push( elem );
2797       break;
2798      }
2799     }
2800     if ( outermost ) {
2801      dirruns = dirrunsUnique;
2802     }
2803    }
2804
2805    // Track unmatched elements for set filters
2806    if ( bySet ) {
2807     // They will have gone through all possible matchers
2808     if ( (elem = !matcher && elem) ) {
2809      matchedCount--;
2810     }
2811
2812     // Lengthen the array for every element, matched or not
2813     if ( seed ) {
2814      unmatched.push( elem );
2815     }
2816    }
2817   }
2818
2819   // Apply set filters to unmatched elements
2820   matchedCount += i;
2821   if ( bySet && i !== matchedCount ) {
2822    j = 0;
2823    while ( (matcher = setMatchers[j++]) ) {
2824     matcher( unmatched, setMatched, context, xml );
2825    }
2826
2827    if ( seed ) {
2828     // Reintegrate element matches to eliminate the need for sorting
2829     if ( matchedCount > 0 ) {
2830      while ( i-- ) {
2831       if ( !(unmatched[i] || setMatched[i]) ) {
2832        setMatched[i] = pop.call( results );
2833       }
2834      }
2835     }
2836
2837     // Discard index placeholder values to get only actual matches
2838     setMatched = condense( setMatched );
2839    }
2840
2841    // Add matches to results
2842    push.apply( results, setMatched );
2843
2844    // Seedless set matches succeeding multiple successful matchers stipulate sorting
2845    if ( outermost && !seed && setMatched.length > 0 &&
2846     ( matchedCount + setMatchers.length ) > 1 ) {
2847
2848     Sizzle.uniqueSort( results );
2849    }
2850   }
2851
2852   // Override manipulation of globals by nested matchers
2853   if ( outermost ) {
2854    dirruns = dirrunsUnique;
2855    outermostContext = contextBackup;
2856   }
2857
2858   return unmatched;
2859  };
2860
2861 return bySet ?
2862  markFunction( superMatcher ) :
2863  superMatcher;
2864}
2865
2866compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2867 var i,
2868  setMatchers = [],
2869  elementMatchers = [],
2870  cached = compilerCache[ selector + " " ];
2871
2872 if ( !cached ) {
2873  // Generate a function of recursive functions that can be used to check each element
2874  if ( !match ) {
2875   match = tokenize( selector );
2876  }
2877  i = match.length;
2878  while ( i-- ) {
2879   cached = matcherFromTokens( match[i] );
2880   if ( cached[ expando ] ) {
2881    setMatchers.push( cached );
2882   } else {
2883    elementMatchers.push( cached );
2884   }
2885  }
2886
2887  // Cache the compiled function
2888  cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2889
2890  // Save selector and tokenization
2891  cached.selector = selector;
2892 }
2893 return cached;
2894};
2895
2896/**
2897 * A low-level selection function that works with Sizzle's compiled
2898 *  selector functions
2899 * @param {String|Function} selector A selector or a pre-compiled
2900 *  selector function built with Sizzle.compile
2901 * @param {Element} context
2902 * @param {Array} [results]
2903 * @param {Array} [seed] A set of elements to match against
2904 */
2905select = Sizzle.select = function( selector, context, results, seed ) {
2906 var i, tokens, token, type, find,
2907  compiled = typeof selector === "function" && selector,
2908  match = !seed && tokenize( (selector = compiled.selector || selector) );
2909
2910 results = results || [];
2911
2912 // Try to minimize operations if there is no seed and only one group
2913 if ( match.length === 1 ) {
2914
2915  // Take a shortcut and set the context if the root selector is an ID
2916  tokens = match[0] = match[0].slice( 0 );
2917  if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2918    support.getById && context.nodeType === 9 && documentIsHTML &&
2919    Expr.relative[ tokens[1].type ] ) {
2920
2921   context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2922   if ( !context ) {
2923    return results;
2924
2925   // Precompiled matchers will still verify ancestry, so step up a level
2926   } else if ( compiled ) {
2927    context = context.parentNode;
2928   }
2929
2930   selector = selector.slice( tokens.shift().value.length );
2931  }
2932
2933  // Fetch a seed set for right-to-left matching
2934  i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2935  while ( i-- ) {
2936   token = tokens[i];
2937
2938   // Abort if we hit a combinator
2939   if ( Expr.relative[ (type = token.type) ] ) {
2940    break;
2941   }
2942   if ( (find = Expr.find[ type ]) ) {
2943    // Search, expanding context for leading sibling combinators
2944    if ( (seed = find(
2945     token.matches[0].replace( runescape, funescape ),
2946     rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2947    )) ) {
2948
2949     // If seed is empty or no tokens remain, we can return early
2950     tokens.splice( i, 1 );
2951     selector = seed.length && toSelector( tokens );
2952     if ( !selector ) {
2953      push.apply( results, seed );
2954      return results;
2955     }
2956
2957     break;
2958    }
2959   }
2960  }
2961 }
2962
2963 // Compile and execute a filtering function if one is not provided
2964 // Provide `match` to avoid retokenization if we modified the selector above
2965 ( compiled || compile( selector, match ) )(
2966  seed,
2967  context,
2968  !documentIsHTML,
2969  results,
2970  rsibling.test( selector ) && testContext( context.parentNode ) || context
2971 );
2972 return results;
2973};
2974
2975// One-time assignments
2976
2977// Sort stability
2978support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2979
2980// Support: Chrome<14
2981// Always assume duplicates if they aren't passed to the comparison function
2982support.detectDuplicates = !!hasDuplicate;
2983
2984// Initialize against the default document
2985setDocument();
2986
2987// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2988// Detached nodes confoundingly follow *each other*
2989support.sortDetached = assert(function( div1 ) {
2990 // Should return 1, but returns 4 (following)
2991 return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2992});
2993
2994// Support: IE<8
2995// Prevent attribute/property "interpolation"
2996// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2997if ( !assert(function( div ) {
2998 div.innerHTML = "<a href='#'></a>";
2999 return div.firstChild.getAttribute("href") === "#" ;
3000}) ) {
3001 addHandle( "type|href|height|width", function( elem, name, isXML ) {
3002  if ( !isXML ) {
3003   return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
3004  }
3005 });
3006}
3007
3008// Support: IE<9
3009// Use defaultValue in place of getAttribute("value")
3010if ( !support.attributes || !assert(function( div ) {
3011 div.innerHTML = "<input/>";
3012 div.firstChild.setAttribute( "value", "" );
3013 return div.firstChild.getAttribute( "value" ) === "";
3014}) ) {
3015 addHandle( "value", function( elem, name, isXML ) {
3016  if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
3017   return elem.defaultValue;
3018  }
3019 });
3020}
3021
3022// Support: IE<9
3023// Use getAttributeNode to fetch booleans when getAttribute lies
3024if ( !assert(function( div ) {
3025 return div.getAttribute("disabled") == null;
3026}) ) {
3027 addHandle( booleans, function( elem, name, isXML ) {
3028  var val;
3029  if ( !isXML ) {
3030   return elem[ name ] === true ? name.toLowerCase() :
3031     (val = elem.getAttributeNode( name )) && val.specified ?
3032     val.value :
3033    null;
3034  }
3035 });
3036}
3037
3038return Sizzle;
3039
3040})( window );
3041
3042jQuery.find = Sizzle;
3043jQuery.expr = Sizzle.selectors;
3044jQuery.expr[":"] = jQuery.expr.pseudos;
3045jQuery.unique = Sizzle.uniqueSort;
3046jQuery.text = Sizzle.getText;
3047jQuery.isXMLDoc = Sizzle.isXML;
3048jQuery.contains = Sizzle.contains;
3049
3050var rneedsContext = jQuery.expr.match.needsContext;
3051
3052var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
3053
3054var risSimple = /^.[^:#\[\.,]*$/;
3055
3056// Implement the identical functionality for filter and not
3057function winnow( elements, qualifier, not ) {
3058 if ( jQuery.isFunction( qualifier ) ) {
3059  return jQuery.grep( elements, function( elem, i ) {
3060   /* jshint -W018 */
3061   return !!qualifier.call( elem, i, elem ) !== not;
3062  });
3063
3064 }
3065
3066 if ( qualifier.nodeType ) {
3067  return jQuery.grep( elements, function( elem ) {
3068   return ( elem === qualifier ) !== not;
3069  });
3070
3071 }
3072
3073 if ( typeof qualifier === "string" ) {
3074  if ( risSimple.test( qualifier ) ) {
3075   return jQuery.filter( qualifier, elements, not );
3076  }
3077
3078  qualifier = jQuery.filter( qualifier, elements );
3079 }
3080
3081 return jQuery.grep( elements, function( elem ) {
3082  return ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not;
3083 });
3084}
3085
3086jQuery.filter = function( expr, elems, not ) {
3087 var elem = elems[ 0 ];
3088
3089 if ( not ) {
3090  expr = ":not(" + expr + ")";
3091 }
3092
3093 return elems.length === 1 && elem.nodeType === 1 ?
3094  jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
3095  jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
3096   return elem.nodeType === 1;
3097  }));
3098};
3099
3100jQuery.fn.extend({
3101 find: function( selector ) {
3102  var i,
3103   ret = [],
3104   self = this,
3105   len = self.length;
3106
3107  if ( typeof selector !== "string" ) {
3108   return this.pushStack( jQuery( selector ).filter(function() {
3109    for ( i = 0; i < len; i++ ) {
3110     if ( jQuery.contains( self[ i ], this ) ) {
3111      return true;
3112     }
3113    }
3114   }) );
3115  }
3116
3117  for ( i = 0; i < len; i++ ) {
3118   jQuery.find( selector, self[ i ], ret );
3119  }
3120
3121  // Needed because $( selector, context ) becomes $( context ).find( selector )
3122  ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
3123  ret.selector = this.selector ? this.selector + " " + selector : selector;
3124  return ret;
3125 },
3126 filter: function( selector ) {
3127  return this.pushStack( winnow(this, selector || [], false) );
3128 },
3129 not: function( selector ) {
3130  return this.pushStack( winnow(this, selector || [], true) );
3131 },
3132 is: function( selector ) {
3133  return !!winnow(
3134   this,
3135
3136   // If this is a positional/relative selector, check membership in the returned set
3137   // so $("p:first").is("p:last") won't return true for a doc with two "p".
3138   typeof selector === "string" && rneedsContext.test( selector ) ?
3139    jQuery( selector ) :
3140    selector || [],
3141   false
3142  ).length;
3143 }
3144});
3145
3146// Initialize a jQuery object
3147
3148// A central reference to the root jQuery(document)
3149var rootjQuery,
3150
3151 // Use the correct document accordingly with window argument (sandbox)
3152 document = window.document,
3153
3154 // A simple way to check for HTML strings
3155 // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
3156 // Strict HTML recognition (#11290: must start with <)
3157 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
3158
3159 init = jQuery.fn.init = function( selector, context ) {
3160  var match, elem;
3161
3162  // HANDLE: $(""), $(null), $(undefined), $(false)
3163  if ( !selector ) {
3164   return this;
3165  }
3166
3167  // Handle HTML strings
3168  if ( typeof selector === "string" ) {
3169   if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
3170    // Assume that strings that start and end with <> are HTML and skip the regex check
3171    match = [ null, selector, null ];
3172
3173   } else {
3174    match = rquickExpr.exec( selector );
3175   }
3176
3177   // Match html or make sure no context is specified for #id
3178   if ( match && (match[1] || !context) ) {
3179
3180    // HANDLE: $(html) -> $(array)
3181    if ( match[1] ) {
3182     context = context instanceof jQuery ? context[0] : context;
3183
3184     // scripts is true for back-compat
3185     // Intentionally let the error be thrown if parseHTML is not present
3186     jQuery.merge( this, jQuery.parseHTML(
3187      match[1],
3188      context && context.nodeType ? context.ownerDocument || context : document,
3189      true
3190     ) );
3191
3192     // HANDLE: $(html, props)
3193     if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
3194      for ( match in context ) {
3195       // Properties of context are called as methods if possible
3196       if ( jQuery.isFunction( this[ match ] ) ) {
3197        this[ match ]( context[ match ] );
3198
3199       // ...and otherwise set as attributes
3200       } else {
3201        this.attr( match, context[ match ] );
3202       }
3203      }
3204     }
3205
3206     return this;
3207
3208    // HANDLE: $(#id)
3209    } else {
3210     elem = document.getElementById( match[2] );
3211
3212     // Check parentNode to catch when Blackberry 4.6 returns
3213     // nodes that are no longer in the document #6963
3214     if ( elem && elem.parentNode ) {
3215      // Handle the case where IE and Opera return items
3216      // by name instead of ID
3217      if ( elem.id !== match[2] ) {
3218       return rootjQuery.find( selector );
3219      }
3220
3221      // Otherwise, we inject the element directly into the jQuery object
3222      this.length = 1;
3223      this[0] = elem;
3224     }
3225
3226     this.context = document;
3227     this.selector = selector;
3228     return this;
3229    }
3230
3231   // HANDLE: $(expr, $(...))
3232   } else if ( !context || context.jquery ) {
3233    return ( context || rootjQuery ).find( selector );
3234
3235   // HANDLE: $(expr, context)
3236   // (which is just equivalent to: $(context).find(expr)
3237   } else {
3238    return this.constructor( context ).find( selector );
3239   }
3240
3241  // HANDLE: $(DOMElement)
3242  } else if ( selector.nodeType ) {
3243   this.context = this[0] = selector;
3244   this.length = 1;
3245   return this;
3246
3247  // HANDLE: $(function)
3248  // Shortcut for document ready
3249  } else if ( jQuery.isFunction( selector ) ) {
3250   return typeof rootjQuery.ready !== "undefined" ?
3251    rootjQuery.ready( selector ) :
3252    // Execute immediately if ready is not present
3253    selector( jQuery );
3254  }
3255
3256  if ( selector.selector !== undefined ) {
3257   this.selector = selector.selector;
3258   this.context = selector.context;
3259  }
3260
3261  return jQuery.makeArray( selector, this );
3262 };
3263
3264// Give the init function the jQuery prototype for later instantiation
3265init.prototype = jQuery.fn;
3266
3267// Initialize central reference
3268rootjQuery = jQuery( document );
3269
3270var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3271 // methods guaranteed to produce a unique set when starting from a unique set
3272 guaranteedUnique = {
3273  children: true,
3274  contents: true,
3275  next: true,
3276  prev: true
3277 };
3278
3279jQuery.extend({
3280 dir: function( elem, dir, until ) {
3281  var matched = [],
3282   cur = elem[ dir ];
3283
3284  while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
3285   if ( cur.nodeType === 1 ) {
3286    matched.push( cur );
3287   }
3288   cur = cur[dir];
3289  }
3290  return matched;
3291 },
3292
3293 sibling: function( n, elem ) {
3294  var r = [];
3295
3296  for ( ; n; n = n.nextSibling ) {
3297   if ( n.nodeType === 1 && n !== elem ) {
3298    r.push( n );
3299   }
3300  }
3301
3302  return r;
3303 }
3304});
3305
3306jQuery.fn.extend({
3307 has: function( target ) {
3308  var i,
3309   targets = jQuery( target, this ),
3310   len = targets.length;
3311
3312  return this.filter(function() {
3313   for ( i = 0; i < len; i++ ) {
3314    if ( jQuery.contains( this, targets[i] ) ) {
3315     return true;
3316    }
3317   }
3318  });
3319 },
3320
3321 closest: function( selectors, context ) {
3322  var cur,
3323   i = 0,
3324   l = this.length,
3325   matched = [],
3326   pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
3327    jQuery( selectors, context || this.context ) :
3328    0;
3329
3330  for ( ; i < l; i++ ) {
3331   for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
3332    // Always skip document fragments
3333    if ( cur.nodeType < 11 && (pos ?
3334     pos.index(cur) > -1 :
3335
3336     // Don't pass non-elements to Sizzle
3337     cur.nodeType === 1 &&
3338      jQuery.find.matchesSelector(cur, selectors)) ) {
3339
3340     matched.push( cur );
3341     break;
3342    }
3343   }
3344  }
3345
3346  return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
3347 },
3348
3349 // Determine the position of an element within
3350 // the matched set of elements
3351 index: function( elem ) {
3352
3353  // No argument, return index in parent
3354  if ( !elem ) {
3355   return ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1;
3356  }
3357
3358  // index in selector
3359  if ( typeof elem === "string" ) {
3360   return jQuery.inArray( this[0], jQuery( elem ) );
3361  }
3362
3363  // Locate the position of the desired element
3364  return jQuery.inArray(
3365   // If it receives a jQuery object, the first element is used
3366   elem.jquery ? elem[0] : elem, this );
3367 },
3368
3369 add: function( selector, context ) {
3370  return this.pushStack(
3371   jQuery.unique(
3372    jQuery.merge( this.get(), jQuery( selector, context ) )
3373   )
3374  );
3375 },
3376
3377 addBack: function( selector ) {
3378  return this.add( selector == null ?
3379   this.prevObject : this.prevObject.filter(selector)
3380  );
3381 }
3382});
3383
3384function sibling( cur, dir ) {
3385 do {
3386  cur = cur[ dir ];
3387 } while ( cur && cur.nodeType !== 1 );
3388
3389 return cur;
3390}
3391
3392jQuery.each({
3393 parent: function( elem ) {
3394  var parent = elem.parentNode;
3395  return parent && parent.nodeType !== 11 ? parent : null;
3396 },
3397 parents: function( elem ) {
3398  return jQuery.dir( elem, "parentNode" );
3399 },
3400 parentsUntil: function( elem, i, until ) {
3401  return jQuery.dir( elem, "parentNode", until );
3402 },
3403 next: function( elem ) {
3404  return sibling( elem, "nextSibling" );
3405 },
3406 prev: function( elem ) {
3407  return sibling( elem, "previousSibling" );
3408 },
3409 nextAll: function( elem ) {
3410  return jQuery.dir( elem, "nextSibling" );
3411 },
3412 prevAll: function( elem ) {
3413  return jQuery.dir( elem, "previousSibling" );
3414 },
3415 nextUntil: function( elem, i, until ) {
3416  return jQuery.dir( elem, "nextSibling", until );
3417 },
3418 prevUntil: function( elem, i, until ) {
3419  return jQuery.dir( elem, "previousSibling", until );
3420 },
3421 siblings: function( elem ) {
3422  return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
3423 },
3424 children: function( elem ) {
3425  return jQuery.sibling( elem.firstChild );
3426 },
3427 contents: function( elem ) {
3428  return jQuery.nodeName( elem, "iframe" ) ?
3429   elem.contentDocument || elem.contentWindow.document :
3430   jQuery.merge( [], elem.childNodes );
3431 }
3432}, function( name, fn ) {
3433 jQuery.fn[ name ] = function( until, selector ) {
3434  var ret = jQuery.map( this, fn, until );
3435
3436  if ( name.slice( -5 ) !== "Until" ) {
3437   selector = until;
3438  }
3439
3440  if ( selector && typeof selector === "string" ) {
3441   ret = jQuery.filter( selector, ret );
3442  }
3443
3444  if ( this.length > 1 ) {
3445   // Remove duplicates
3446   if ( !guaranteedUnique[ name ] ) {
3447    ret = jQuery.unique( ret );
3448   }
3449
3450   // Reverse order for parents* and prev-derivatives
3451   if ( rparentsprev.test( name ) ) {
3452    ret = ret.reverse();
3453   }
3454  }
3455
3456  return this.pushStack( ret );
3457 };
3458});
3459var rnotwhite = (/\S+/g);
3460
3461// String to Object options format cache
3462var optionsCache = {};
3463
3464// Convert String-formatted options into Object-formatted ones and store in cache
3465function createOptions( options ) {
3466 var object = optionsCache[ options ] = {};
3467 jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
3468  object[ flag ] = true;
3469 });
3470 return object;
3471}
3472
3473/*
3474 * Create a callback list using the following parameters:
3475 *
3476 * options: an optional list of space-separated options that will change how
3477 *   the callback list behaves or a more traditional option object
3478 *
3479 * By default a callback list will act like an event callback list and can be
3480 * "fired" multiple times.
3481 *
3482 * Possible options:
3483 *
3484 * once:   will ensure the callback list can only be fired once (like a Deferred)
3485 *
3486 * memory:   will keep track of previous values and will call any callback added
3487 *     after the list has been fired right away with the latest "memorized"
3488 *     values (like a Deferred)
3489 *
3490 * unique:   will ensure a callback can only be added once (no duplicate in the list)
3491 *
3492 * stopOnFalse: interrupt callings when a callback returns false
3493 *
3494 */
3495jQuery.Callbacks = function( options ) {
3496
3497 // Convert options from String-formatted to Object-formatted if needed
3498 // (we check in cache first)
3499 options = typeof options === "string" ?
3500  ( optionsCache[ options ] || createOptions( options ) ) :
3501  jQuery.extend( {}, options );
3502
3503 var // Flag to know if list is currently firing
3504  firing,
3505  // Last fire value (for non-forgettable lists)
3506  memory,
3507  // Flag to know if list was already fired
3508  fired,
3509  // End of the loop when firing
3510  firingLength,
3511  // Index of currently firing callback (modified by remove if needed)
3512  firingIndex,
3513  // First callback to fire (used internally by add and fireWith)
3514  firingStart,
3515  // Actual callback list
3516  list = [],
3517  // Stack of fire calls for repeatable lists
3518  stack = !options.once && [],
3519  // Fire callbacks
3520  fire = function( data ) {
3521   memory = options.memory && data;
3522   fired = true;
3523   firingIndex = firingStart || 0;
3524   firingStart = 0;
3525   firingLength = list.length;
3526   firing = true;
3527   for ( ; list && firingIndex < firingLength; firingIndex++ ) {
3528    if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
3529     memory = false; // To prevent further calls using add
3530     break;
3531    }
3532   }
3533   firing = false;
3534   if ( list ) {
3535    if ( stack ) {
3536     if ( stack.length ) {
3537      fire( stack.shift() );
3538     }
3539    } else if ( memory ) {
3540     list = [];
3541    } else {
3542     self.disable();
3543    }
3544   }
3545  },
3546  // Actual Callbacks object
3547  self = {
3548   // Add a callback or a collection of callbacks to the list
3549   add: function() {
3550    if ( list ) {
3551     // First, we save the current length
3552     var start = list.length;
3553     (function add( args ) {
3554      jQuery.each( args, function( _, arg ) {
3555       var type = jQuery.type( arg );
3556       if ( type === "function" ) {
3557        if ( !options.unique || !self.has( arg ) ) {
3558         list.push( arg );
3559        }
3560       } else if ( arg && arg.length && type !== "string" ) {
3561        // Inspect recursively
3562        add( arg );
3563       }
3564      });
3565     })( arguments );
3566     // Do we need to add the callbacks to the
3567     // current firing batch?
3568     if ( firing ) {
3569      firingLength = list.length;
3570     // With memory, if we're not firing then
3571     // we should call right away
3572     } else if ( memory ) {
3573      firingStart = start;
3574      fire( memory );
3575     }
3576    }
3577    return this;
3578   },
3579   // Remove a callback from the list
3580   remove: function() {
3581    if ( list ) {
3582     jQuery.each( arguments, function( _, arg ) {
3583      var index;
3584      while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3585       list.splice( index, 1 );
3586       // Handle firing indexes
3587       if ( firing ) {
3588        if ( index <= firingLength ) {
3589         firingLength--;
3590        }
3591        if ( index <= firingIndex ) {
3592         firingIndex--;
3593        }
3594       }
3595      }
3596     });
3597    }
3598    return this;
3599   },
3600   // Check if a given callback is in the list.
3601   // If no argument is given, return whether or not list has callbacks attached.
3602   has: function( fn ) {
3603    return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
3604   },
3605   // Remove all callbacks from the list
3606   empty: function() {
3607    list = [];
3608    firingLength = 0;
3609    return this;
3610   },
3611   // Have the list do nothing anymore
3612   disable: function() {
3613    list = stack = memory = undefined;
3614    return this;
3615   },
3616   // Is it disabled?
3617   disabled: function() {
3618    return !list;
3619   },
3620   // Lock the list in its current state
3621   lock: function() {
3622    stack = undefined;
3623    if ( !memory ) {
3624     self.disable();
3625    }
3626    return this;
3627   },
3628   // Is it locked?
3629   locked: function() {
3630    return !stack;
3631   },
3632   // Call all callbacks with the given context and arguments
3633   fireWith: function( context, args ) {
3634    if ( list && ( !fired || stack ) ) {
3635     args = args || [];
3636     args = [ context, args.slice ? args.slice() : args ];
3637     if ( firing ) {
3638      stack.push( args );
3639     } else {
3640      fire( args );
3641     }
3642    }
3643    return this;
3644   },
3645   // Call all the callbacks with the given arguments
3646   fire: function() {
3647    self.fireWith( this, arguments );
3648    return this;
3649   },
3650   // To know if the callbacks have already been called at least once
3651   fired: function() {
3652    return !!fired;
3653   }
3654  };
3655
3656 return self;
3657};
3658
3659jQuery.extend({
3660
3661 Deferred: function( func ) {
3662  var tuples = [
3663    // action, add listener, listener list, final state
3664    [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
3665    [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
3666    [ "notify", "progress", jQuery.Callbacks("memory") ]
3667   ],
3668   state = "pending",
3669   promise = {
3670    state: function() {
3671     return state;
3672    },
3673    always: function() {
3674     deferred.done( arguments ).fail( arguments );
3675     return this;
3676    },
3677    then: function( /* fnDone, fnFail, fnProgress */ ) {
3678     var fns = arguments;
3679     return jQuery.Deferred(function( newDefer ) {
3680      jQuery.each( tuples, function( i, tuple ) {
3681       var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3682       // deferred[ done | fail | progress ] for forwarding actions to newDefer
3683       deferred[ tuple[1] ](function() {
3684        var returned = fn && fn.apply( this, arguments );
3685        if ( returned && jQuery.isFunction( returned.promise ) ) {
3686         returned.promise()
3687          .done( newDefer.resolve )
3688          .fail( newDefer.reject )
3689          .progress( newDefer.notify );
3690        } else {
3691         newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
3692        }
3693       });
3694      });
3695      fns = null;
3696     }).promise();
3697    },
3698    // Get a promise for this deferred
3699    // If obj is provided, the promise aspect is added to the object
3700    promise: function( obj ) {
3701     return obj != null ? jQuery.extend( obj, promise ) : promise;
3702    }
3703   },
3704   deferred = {};
3705
3706  // Keep pipe for back-compat
3707  promise.pipe = promise.then;
3708
3709  // Add list-specific methods
3710  jQuery.each( tuples, function( i, tuple ) {
3711   var list = tuple[ 2 ],
3712    stateString = tuple[ 3 ];
3713
3714   // promise[ done | fail | progress ] = list.add
3715   promise[ tuple[1] ] = list.add;
3716
3717   // Handle state
3718   if ( stateString ) {
3719    list.add(function() {
3720     // state = [ resolved | rejected ]
3721     state = stateString;
3722
3723    // [ reject_list | resolve_list ].disable; progress_list.lock
3724    }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3725   }
3726
3727   // deferred[ resolve | reject | notify ]
3728   deferred[ tuple[0] ] = function() {
3729    deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
3730    return this;
3731   };
3732   deferred[ tuple[0] + "With" ] = list.fireWith;
3733  });
3734
3735  // Make the deferred a promise
3736  promise.promise( deferred );
3737
3738  // Call given func if any
3739  if ( func ) {
3740   func.call( deferred, deferred );
3741  }
3742
3743  // All done!
3744  return deferred;
3745 },
3746
3747 // Deferred helper
3748 when: function( subordinate /* , ..., subordinateN */ ) {
3749  var i = 0,
3750   resolveValues = slice.call( arguments ),
3751   length = resolveValues.length,
3752
3753   // the count of uncompleted subordinates
3754   remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
3755
3756   // the master Deferred. If resolveValues consist of only a single Deferred, just use that.
3757   deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
3758
3759   // Update function for both resolve and progress values
3760   updateFunc = function( i, contexts, values ) {
3761    return function( value ) {
3762     contexts[ i ] = this;
3763     values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
3764     if ( values === progressValues ) {
3765      deferred.notifyWith( contexts, values );
3766
3767     } else if ( !(--remaining) ) {
3768      deferred.resolveWith( contexts, values );
3769     }
3770    };
3771   },
3772
3773   progressValues, progressContexts, resolveContexts;
3774
3775  // add listeners to Deferred subordinates; treat others as resolved
3776  if ( length > 1 ) {
3777   progressValues = new Array( length );
3778   progressContexts = new Array( length );
3779   resolveContexts = new Array( length );
3780   for ( ; i < length; i++ ) {
3781    if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
3782     resolveValues[ i ].promise()
3783      .done( updateFunc( i, resolveContexts, resolveValues ) )
3784      .fail( deferred.reject )
3785      .progress( updateFunc( i, progressContexts, progressValues ) );
3786    } else {
3787     --remaining;
3788    }
3789   }
3790  }
3791
3792  // if we're not waiting on anything, resolve the master
3793  if ( !remaining ) {
3794   deferred.resolveWith( resolveContexts, resolveValues );
3795  }
3796
3797  return deferred.promise();
3798 }
3799});
3800
3801// The deferred used on DOM ready
3802var readyList;
3803
3804jQuery.fn.ready = function( fn ) {
3805 // Add the callback
3806 jQuery.ready.promise().done( fn );
3807
3808 return this;
3809};
3810
3811jQuery.extend({
3812 // Is the DOM ready to be used? Set to true once it occurs.
3813 isReady: false,
3814
3815 // A counter to track how many items to wait for before
3816 // the ready event fires. See #6781
3817 readyWait: 1,
3818
3819 // Hold (or release) the ready event
3820 holdReady: function( hold ) {
3821  if ( hold ) {
3822   jQuery.readyWait++;
3823  } else {
3824   jQuery.ready( true );
3825  }
3826 },
3827
3828 // Handle when the DOM is ready
3829 ready: function( wait ) {
3830
3831  // Abort if there are pending holds or we're already ready
3832  if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
3833   return;
3834  }
3835
3836  // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
3837  if ( !document.body ) {
3838   return setTimeout( jQuery.ready );
3839  }
3840
3841  // Remember that the DOM is ready
3842  jQuery.isReady = true;
3843
3844  // If a normal DOM Ready event fired, decrement, and wait if need be
3845  if ( wait !== true && --jQuery.readyWait > 0 ) {
3846   return;
3847  }
3848
3849  // If there are functions bound, to execute
3850  readyList.resolveWith( document, [ jQuery ] );
3851
3852  // Trigger any bound ready events
3853  if ( jQuery.fn.triggerHandler ) {
3854   jQuery( document ).triggerHandler( "ready" );
3855   jQuery( document ).off( "ready" );
3856  }
3857 }
3858});
3859
3860/**
3861 * Clean-up method for dom ready events
3862 */
3863function detach() {
3864 if ( document.addEventListener ) {
3865  document.removeEventListener( "DOMContentLoaded", completed, false );
3866  window.removeEventListener( "load", completed, false );
3867
3868 } else {
3869  document.detachEvent( "onreadystatechange", completed );
3870  window.detachEvent( "onload", completed );
3871 }
3872}
3873
3874/**
3875 * The ready event handler and self cleanup method
3876 */
3877function completed() {
3878 // readyState === "complete" is good enough for us to call the dom ready in oldIE
3879 if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
3880  detach();
3881  jQuery.ready();
3882 }
3883}
3884
3885jQuery.ready.promise = function( obj ) {
3886 if ( !readyList ) {
3887
3888  readyList = jQuery.Deferred();
3889
3890  // Catch cases where $(document).ready() is called after the browser event has already occurred.
3891  // we once tried to use readyState "interactive" here, but it caused issues like the one
3892  // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
3893  if ( document.readyState === "complete" ) {
3894   // Handle it asynchronously to allow scripts the opportunity to delay ready
3895   setTimeout( jQuery.ready );
3896
3897  // Standards-based browsers support DOMContentLoaded
3898  } else if ( document.addEventListener ) {
3899   // Use the handy event callback
3900   document.addEventListener( "DOMContentLoaded", completed, false );
3901
3902   // A fallback to window.onload, that will always work
3903   window.addEventListener( "load", completed, false );
3904
3905  // If IE event model is used
3906  } else {
3907   // Ensure firing before onload, maybe late but safe also for iframes
3908   document.attachEvent( "onreadystatechange", completed );
3909
3910   // A fallback to window.onload, that will always work
3911   window.attachEvent( "onload", completed );
3912
3913   // If IE and not a frame
3914   // continually check to see if the document is ready
3915   var top = false;
3916
3917   try {
3918    top = window.frameElement == null && document.documentElement;
3919   } catch(e) {}
3920
3921   if ( top && top.doScroll ) {
3922    (function doScrollCheck() {
3923     if ( !jQuery.isReady ) {
3924
3925      try {
3926       // Use the trick by Diego Perini
3927       // http://javascript.nwbox.com/IEContentLoaded/
3928       top.doScroll("left");
3929      } catch(e) {
3930       return setTimeout( doScrollCheck, 50 );
3931      }
3932
3933      // detach all dom ready events
3934      detach();
3935
3936      // and execute any waiting functions
3937      jQuery.ready();
3938     }
3939    })();
3940   }
3941  }
3942 }
3943 return readyList.promise( obj );
3944};
3945
3946var strundefined = typeof undefined;
3947
3948// Support: IE<9
3949// Iteration over object's inherited properties before its own
3950var i;
3951for ( i in jQuery( support ) ) {
3952 break;
3953}
3954support.ownLast = i !== "0";
3955
3956// Note: most support tests are defined in their respective modules.
3957// false until the test is run
3958support.inlineBlockNeedsLayout = false;
3959
3960// Execute ASAP in case we need to set body.style.zoom
3961jQuery(function() {
3962 // Minified: var a,b,c,d
3963 var val, div, body, container;
3964
3965 body = document.getElementsByTagName( "body" )[ 0 ];
3966 if ( !body || !body.style ) {
3967  // Return for frameset docs that don't have a body
3968  return;
3969 }
3970
3971 // Setup
3972 div = document.createElement( "div" );
3973 container = document.createElement( "div" );
3974 container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
3975 body.appendChild( container ).appendChild( div );
3976
3977 if ( typeof div.style.zoom !== strundefined ) {
3978  // Support: IE<8
3979  // Check if natively block-level elements act like inline-block
3980  // elements when setting their display to 'inline' and giving
3981  // them layout
3982  div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1";
3983
3984  support.inlineBlockNeedsLayout = val = div.offsetWidth === 3;
3985  if ( val ) {
3986   // Prevent IE 6 from affecting layout for positioned elements #11048
3987   // Prevent IE from shrinking the body in IE 7 mode #12869
3988   // Support: IE<8
3989   body.style.zoom = 1;
3990  }
3991 }
3992
3993 body.removeChild( container );
3994});
3995
3996(function() {
3997 var div = document.createElement( "div" );
3998
3999 // Execute the test only if not already executed in another module.
4000 if (support.deleteExpando == null) {
4001  // Support: IE<9
4002  support.deleteExpando = true;
4003  try {
4004   delete div.test;
4005  } catch( e ) {
4006   support.deleteExpando = false;
4007  }
4008 }
4009
4010 // Null elements to avoid leaks in IE.
4011 div = null;
4012})();
4013
4014/**
4015 * Determines whether an object can have data
4016 */
4017jQuery.acceptData = function( elem ) {
4018 var noData = jQuery.noData[ (elem.nodeName + " ").toLowerCase() ],
4019  nodeType = +elem.nodeType || 1;
4020
4021 // Do not set data on non-element DOM nodes because it will not be cleared (#8335).
4022 return nodeType !== 1 && nodeType !== 9 ?
4023  false :
4024
4025  // Nodes accept data unless otherwise specified; rejection can be conditional
4026  !noData || noData !== true && elem.getAttribute("classid") === noData;
4027};
4028
4029var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
4030 rmultiDash = /([A-Z])/g;
4031
4032function dataAttr( elem, key, data ) {
4033 // If nothing was found internally, try to fetch any
4034 // data from the HTML5 data-* attribute
4035 if ( data === undefined && elem.nodeType === 1 ) {
4036
4037  var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
4038
4039  data = elem.getAttribute( name );
4040
4041  if ( typeof data === "string" ) {
4042   try {
4043    data = data === "true" ? true :
4044     data === "false" ? false :
4045     data === "null" ? null :
4046     // Only convert to a number if it doesn't change the string
4047     +data + "" === data ? +data :
4048     rbrace.test( data ) ? jQuery.parseJSON( data ) :
4049     data;
4050   } catch( e ) {}
4051
4052   // Make sure we set the data so it isn't changed later
4053   jQuery.data( elem, key, data );
4054
4055  } else {
4056   data = undefined;
4057  }
4058 }
4059
4060 return data;
4061}
4062
4063// checks a cache object for emptiness
4064function isEmptyDataObject( obj ) {
4065 var name;
4066 for ( name in obj ) {
4067
4068  // if the public data object is empty, the private is still empty
4069  if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
4070   continue;
4071  }
4072  if ( name !== "toJSON" ) {
4073   return false;
4074  }
4075 }
4076
4077 return true;
4078}
4079
4080function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
4081 if ( !jQuery.acceptData( elem ) ) {
4082  return;
4083 }
4084
4085 var ret, thisCache,
4086  internalKey = jQuery.expando,
4087
4088  // We have to handle DOM nodes and JS objects differently because IE6-7
4089  // can't GC object references properly across the DOM-JS boundary
4090  isNode = elem.nodeType,
4091
4092  // Only DOM nodes need the global jQuery cache; JS object data is
4093  // attached directly to the object so GC can occur automatically
4094  cache = isNode ? jQuery.cache : elem,
4095
4096  // Only defining an ID for JS objects if its cache already exists allows
4097  // the code to shortcut on the same path as a DOM node with no cache
4098  id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
4099
4100 // Avoid doing any more work than we need to when trying to get data on an
4101 // object that has no data at all
4102 if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && data === undefined && typeof name === "string" ) {
4103  return;
4104 }
4105
4106 if ( !id ) {
4107  // Only DOM nodes need a new unique ID for each element since their data
4108  // ends up in the global cache
4109  if ( isNode ) {
4110   id = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;
4111  } else {
4112   id = internalKey;
4113  }
4114 }
4115
4116 if ( !cache[ id ] ) {
4117  // Avoid exposing jQuery metadata on plain JS objects when the object
4118  // is serialized using JSON.stringify
4119  cache[ id ] = isNode ? {} : { toJSON: jQuery.noop };
4120 }
4121
4122 // An object can be passed to jQuery.data instead of a key/value pair; this gets
4123 // shallow copied over onto the existing cache
4124 if ( typeof name === "object" || typeof name === "function" ) {
4125  if ( pvt ) {
4126   cache[ id ] = jQuery.extend( cache[ id ], name );
4127  } else {
4128   cache[ id ].data = jQuery.extend( cache[ id ].data, name );
4129  }
4130 }
4131
4132 thisCache = cache[ id ];
4133
4134 // jQuery data() is stored in a separate object inside the object's internal data
4135 // cache in order to avoid key collisions between internal data and user-defined
4136 // data.
4137 if ( !pvt ) {
4138  if ( !thisCache.data ) {
4139   thisCache.data = {};
4140  }
4141
4142  thisCache = thisCache.data;
4143 }
4144
4145 if ( data !== undefined ) {
4146  thisCache[ jQuery.camelCase( name ) ] = data;
4147 }
4148
4149 // Check for both converted-to-camel and non-converted data property names
4150 // If a data property was specified
4151 if ( typeof name === "string" ) {
4152
4153  // First Try to find as-is property data
4154  ret = thisCache[ name ];
4155
4156  // Test for null|undefined property data
4157  if ( ret == null ) {
4158
4159   // Try to find the camelCased property
4160   ret = thisCache[ jQuery.camelCase( name ) ];
4161  }
4162 } else {
4163  ret = thisCache;
4164 }
4165
4166 return ret;
4167}
4168
4169function internalRemoveData( elem, name, pvt ) {
4170 if ( !jQuery.acceptData( elem ) ) {
4171  return;
4172 }
4173
4174 var thisCache, i,
4175  isNode = elem.nodeType,
4176
4177  // See jQuery.data for more information
4178  cache = isNode ? jQuery.cache : elem,
4179  id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
4180
4181 // If there is already no cache entry for this object, there is no
4182 // purpose in continuing
4183 if ( !cache[ id ] ) {
4184  return;
4185 }
4186
4187 if ( name ) {
4188
4189  thisCache = pvt ? cache[ id ] : cache[ id ].data;
4190
4191  if ( thisCache ) {
4192
4193   // Support array or space separated string names for data keys
4194   if ( !jQuery.isArray( name ) ) {
4195
4196    // try the string as a key before any manipulation
4197    if ( name in thisCache ) {
4198     name = [ name ];
4199    } else {
4200
4201     // split the camel cased version by spaces unless a key with the spaces exists
4202     name = jQuery.camelCase( name );
4203     if ( name in thisCache ) {
4204      name = [ name ];
4205     } else {
4206      name = name.split(" ");
4207     }
4208    }
4209   } else {
4210    // If "name" is an array of keys...
4211    // When data is initially created, via ("key", "val") signature,
4212    // keys will be converted to camelCase.
4213    // Since there is no way to tell _how_ a key was added, remove
4214    // both plain key and camelCase key. #12786
4215    // This will only penalize the array argument path.
4216    name = name.concat( jQuery.map( name, jQuery.camelCase ) );
4217   }
4218
4219   i = name.length;
4220   while ( i-- ) {
4221    delete thisCache[ name[i] ];
4222   }
4223
4224   // If there is no data left in the cache, we want to continue
4225   // and let the cache object itself get destroyed
4226   if ( pvt ? !isEmptyDataObject(thisCache) : !jQuery.isEmptyObject(thisCache) ) {
4227    return;
4228   }
4229  }
4230 }
4231
4232 // See jQuery.data for more information
4233 if ( !pvt ) {
4234  delete cache[ id ].data;
4235
4236  // Don't destroy the parent cache unless the internal data object
4237  // had been the only thing left in it
4238  if ( !isEmptyDataObject( cache[ id ] ) ) {
4239   return;
4240  }
4241 }
4242
4243 // Destroy the cache
4244 if ( isNode ) {
4245  jQuery.cleanData( [ elem ], true );
4246
4247 // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
4248 /* jshint eqeqeq: false */
4249 } else if ( support.deleteExpando || cache != cache.window ) {
4250  /* jshint eqeqeq: true */
4251  delete cache[ id ];
4252
4253 // When all else fails, null
4254 } else {
4255  cache[ id ] = null;
4256 }
4257}
4258
4259jQuery.extend({
4260 cache: {},
4261
4262 // The following elements (space-suffixed to avoid Object.prototype collisions)
4263 // throw uncatchable exceptions if you attempt to set expando properties
4264 noData: {
4265  "applet ": true,
4266  "embed ": true,
4267  // ...but Flash objects (which have this classid) *can* handle expandos
4268  "object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
4269 },
4270
4271 hasData: function( elem ) {
4272  elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
4273  return !!elem && !isEmptyDataObject( elem );
4274 },
4275
4276 data: function( elem, name, data ) {
4277  return internalData( elem, name, data );
4278 },
4279
4280 removeData: function( elem, name ) {
4281  return internalRemoveData( elem, name );
4282 },
4283
4284 // For internal use only.
4285 _data: function( elem, name, data ) {
4286  return internalData( elem, name, data, true );
4287 },
4288
4289 _removeData: function( elem, name ) {
4290  return internalRemoveData( elem, name, true );
4291 }
4292});
4293
4294jQuery.fn.extend({
4295 data: function( key, value ) {
4296  var i, name, data,
4297   elem = this[0],
4298   attrs = elem && elem.attributes;
4299
4300  // Special expections of .data basically thwart jQuery.access,
4301  // so implement the relevant behavior ourselves
4302
4303  // Gets all values
4304  if ( key === undefined ) {
4305   if ( this.length ) {
4306    data = jQuery.data( elem );
4307
4308    if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
4309     i = attrs.length;
4310     while ( i-- ) {
4311
4312      // Support: IE11+
4313      // The attrs elements can be null (#14894)
4314      if ( attrs[ i ] ) {
4315       name = attrs[ i ].name;
4316       if ( name.indexOf( "data-" ) === 0 ) {
4317        name = jQuery.camelCase( name.slice(5) );
4318        dataAttr( elem, name, data[ name ] );
4319       }
4320      }
4321     }
4322     jQuery._data( elem, "parsedAttrs", true );
4323    }
4324   }
4325
4326   return data;
4327  }
4328
4329  // Sets multiple values
4330  if ( typeof key === "object" ) {
4331   return this.each(function() {
4332    jQuery.data( this, key );
4333   });
4334  }
4335
4336  return arguments.length > 1 ?
4337
4338   // Sets one value
4339   this.each(function() {
4340    jQuery.data( this, key, value );
4341   }) :
4342
4343   // Gets one value
4344   // Try to fetch any internally stored data first
4345   elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;
4346 },
4347
4348 removeData: function( key ) {
4349  return this.each(function() {
4350   jQuery.removeData( this, key );
4351  });
4352 }
4353});
4354
4355jQuery.extend({
4356 queue: function( elem, type, data ) {
4357  var queue;
4358
4359  if ( elem ) {
4360   type = ( type || "fx" ) + "queue";
4361   queue = jQuery._data( elem, type );
4362
4363   // Speed up dequeue by getting out quickly if this is just a lookup
4364   if ( data ) {
4365    if ( !queue || jQuery.isArray(data) ) {
4366     queue = jQuery._data( elem, type, jQuery.makeArray(data) );
4367    } else {
4368     queue.push( data );
4369    }
4370   }
4371   return queue || [];
4372  }
4373 },
4374
4375 dequeue: function( elem, type ) {
4376  type = type || "fx";
4377
4378  var queue = jQuery.queue( elem, type ),
4379   startLength = queue.length,
4380   fn = queue.shift(),
4381   hooks = jQuery._queueHooks( elem, type ),
4382   next = function() {
4383    jQuery.dequeue( elem, type );
4384   };
4385
4386  // If the fx queue is dequeued, always remove the progress sentinel
4387  if ( fn === "inprogress" ) {
4388   fn = queue.shift();
4389   startLength--;
4390  }
4391
4392  if ( fn ) {
4393
4394   // Add a progress sentinel to prevent the fx queue from being
4395   // automatically dequeued
4396   if ( type === "fx" ) {
4397    queue.unshift( "inprogress" );
4398   }
4399
4400   // clear up the last queue stop function
4401   delete hooks.stop;
4402   fn.call( elem, next, hooks );
4403  }
4404
4405  if ( !startLength && hooks ) {
4406   hooks.empty.fire();
4407  }
4408 },
4409
4410 // not intended for public consumption - generates a queueHooks object, or returns the current one
4411 _queueHooks: function( elem, type ) {
4412  var key = type + "queueHooks";
4413  return jQuery._data( elem, key ) || jQuery._data( elem, key, {
4414   empty: jQuery.Callbacks("once memory").add(function() {
4415    jQuery._removeData( elem, type + "queue" );
4416    jQuery._removeData( elem, key );
4417   })
4418  });
4419 }
4420});
4421
4422jQuery.fn.extend({
4423 queue: function( type, data ) {
4424  var setter = 2;
4425
4426  if ( typeof type !== "string" ) {
4427   data = type;
4428   type = "fx";
4429   setter--;
4430  }
4431
4432  if ( arguments.length < setter ) {
4433   return jQuery.queue( this[0], type );
4434  }
4435
4436  return data === undefined ?
4437   this :
4438   this.each(function() {
4439    var queue = jQuery.queue( this, type, data );
4440
4441    // ensure a hooks for this queue
4442    jQuery._queueHooks( this, type );
4443
4444    if ( type === "fx" && queue[0] !== "inprogress" ) {
4445     jQuery.dequeue( this, type );
4446    }
4447   });
4448 },
4449 dequeue: function( type ) {
4450  return this.each(function() {
4451   jQuery.dequeue( this, type );
4452  });
4453 },
4454 clearQueue: function( type ) {
4455  return this.queue( type || "fx", [] );
4456 },
4457 // Get a promise resolved when queues of a certain type
4458 // are emptied (fx is the type by default)
4459 promise: function( type, obj ) {
4460  var tmp,
4461   count = 1,
4462   defer = jQuery.Deferred(),
4463   elements = this,
4464   i = this.length,
4465   resolve = function() {
4466    if ( !( --count ) ) {
4467     defer.resolveWith( elements, [ elements ] );
4468    }
4469   };
4470
4471  if ( typeof type !== "string" ) {
4472   obj = type;
4473   type = undefined;
4474  }
4475  type = type || "fx";
4476
4477  while ( i-- ) {
4478   tmp = jQuery._data( elements[ i ], type + "queueHooks" );
4479   if ( tmp && tmp.empty ) {
4480    count++;
4481    tmp.empty.add( resolve );
4482   }
4483  }
4484  resolve();
4485  return defer.promise( obj );
4486 }
4487});
4488var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;
4489
4490var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4491
4492var isHidden = function( elem, el ) {
4493  // isHidden might be called from jQuery#filter function;
4494  // in that case, element will be second argument
4495  elem = el || elem;
4496  return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
4497 };
4498
4499// Multifunctional method to get and set values of a collection
4500// The value/s can optionally be executed if it's a function
4501var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
4502 var i = 0,
4503  length = elems.length,
4504  bulk = key == null;
4505
4506 // Sets many values
4507 if ( jQuery.type( key ) === "object" ) {
4508  chainable = true;
4509  for ( i in key ) {
4510   jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
4511  }
4512
4513 // Sets one value
4514 } else if ( value !== undefined ) {
4515  chainable = true;
4516
4517  if ( !jQuery.isFunction( value ) ) {
4518   raw = true;
4519  }
4520
4521  if ( bulk ) {
4522   // Bulk operations run against the entire set
4523   if ( raw ) {
4524    fn.call( elems, value );
4525    fn = null;
4526
4527   // ...except when executing function values
4528   } else {
4529    bulk = fn;
4530    fn = function( elem, key, value ) {
4531     return bulk.call( jQuery( elem ), value );
4532    };
4533   }
4534  }
4535
4536  if ( fn ) {
4537   for ( ; i < length; i++ ) {
4538    fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
4539   }
4540  }
4541 }
4542
4543 return chainable ?
4544  elems :
4545
4546  // Gets
4547  bulk ?
4548   fn.call( elems ) :
4549   length ? fn( elems[0], key ) : emptyGet;
4550};
4551var rcheckableType = (/^(?:checkbox|radio)$/i);
4552
4553(function() {
4554 // Minified: var a,b,c
4555 var input = document.createElement( "input" ),
4556  div = document.createElement( "div" ),
4557  fragment = document.createDocumentFragment();
4558
4559 // Setup
4560 div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
4561
4562 // IE strips leading whitespace when .innerHTML is used
4563 support.leadingWhitespace = div.firstChild.nodeType === 3;
4564
4565 // Make sure that tbody elements aren't automatically inserted
4566 // IE will insert them into empty tables
4567 support.tbody = !div.getElementsByTagName( "tbody" ).length;
4568
4569 // Make sure that link elements get serialized correctly by innerHTML
4570 // This requires a wrapper element in IE
4571 support.htmlSerialize = !!div.getElementsByTagName( "link" ).length;
4572
4573 // Makes sure cloning an html5 element does not cause problems
4574 // Where outerHTML is undefined, this still works
4575 support.html5Clone =
4576  document.createElement( "nav" ).cloneNode( true ).outerHTML !== "<:nav></:nav>";
4577
4578 // Check if a disconnected checkbox will retain its checked
4579 // value of true after appended to the DOM (IE6/7)
4580 input.type = "checkbox";
4581 input.checked = true;
4582 fragment.appendChild( input );
4583 support.appendChecked = input.checked;
4584
4585 // Make sure textarea (and checkbox) defaultValue is properly cloned
4586 // Support: IE6-IE11+
4587 div.innerHTML = "<textarea>x</textarea>";
4588 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4589
4590 // #11217 - WebKit loses check when the name is after the checked attribute
4591 fragment.appendChild( div );
4592 div.innerHTML = "<input type='radio' checked='checked' name='t'/>";
4593
4594 // Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
4595 // old WebKit doesn't clone checked state correctly in fragments
4596 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4597
4598 // Support: IE<9
4599 // Opera does not clone events (and typeof div.attachEvent === undefined).
4600 // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
4601 support.noCloneEvent = true;
4602 if ( div.attachEvent ) {
4603  div.attachEvent( "onclick", function() {
4604   support.noCloneEvent = false;
4605  });
4606
4607  div.cloneNode( true ).click();
4608 }
4609
4610 // Execute the test only if not already executed in another module.
4611 if (support.deleteExpando == null) {
4612  // Support: IE<9
4613  support.deleteExpando = true;
4614  try {
4615   delete div.test;
4616  } catch( e ) {
4617   support.deleteExpando = false;
4618  }
4619 }
4620})();
4621
4622(function() {
4623 var i, eventName,
4624  div = document.createElement( "div" );
4625
4626 // Support: IE<9 (lack submit/change bubble), Firefox 23+ (lack focusin event)
4627 for ( i in { submit: true, change: true, focusin: true }) {
4628  eventName = "on" + i;
4629
4630  if ( !(support[ i + "Bubbles" ] = eventName in window) ) {
4631   // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
4632   div.setAttribute( eventName, "t" );
4633   support[ i + "Bubbles" ] = div.attributes[ eventName ].expando === false;
4634  }
4635 }
4636
4637 // Null elements to avoid leaks in IE.
4638 div = null;
4639})();
4640
4641var rformElems = /^(?:input|select|textarea)$/i,
4642 rkeyEvent = /^key/,
4643 rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/,
4644 rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
4645 rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
4646
4647function returnTrue() {
4648 return true;
4649}
4650
4651function returnFalse() {
4652 return false;
4653}
4654
4655function safeActiveElement() {
4656 try {
4657  return document.activeElement;
4658 } catch ( err ) { }
4659}
4660
4661/*
4662 * Helper functions for managing events -- not part of the public interface.
4663 * Props to Dean Edwards' addEvent library for many of the ideas.
4664 */
4665jQuery.event = {
4666
4667 global: {},
4668
4669 add: function( elem, types, handler, data, selector ) {
4670  var tmp, events, t, handleObjIn,
4671   special, eventHandle, handleObj,
4672   handlers, type, namespaces, origType,
4673   elemData = jQuery._data( elem );
4674
4675  // Don't attach events to noData or text/comment nodes (but allow plain objects)
4676  if ( !elemData ) {
4677   return;
4678  }
4679
4680  // Caller can pass in an object of custom data in lieu of the handler
4681  if ( handler.handler ) {
4682   handleObjIn = handler;
4683   handler = handleObjIn.handler;
4684   selector = handleObjIn.selector;
4685  }
4686
4687  // Make sure that the handler has a unique ID, used to find/remove it later
4688  if ( !handler.guid ) {
4689   handler.guid = jQuery.guid++;
4690  }
4691
4692  // Init the element's event structure and main handler, if this is the first
4693  if ( !(events = elemData.events) ) {
4694   events = elemData.events = {};
4695  }
4696  if ( !(eventHandle = elemData.handle) ) {
4697   eventHandle = elemData.handle = function( e ) {
4698    // Discard the second event of a jQuery.event.trigger() and
4699    // when an event is called after a page has unloaded
4700    return typeof jQuery !== strundefined && (!e || jQuery.event.triggered !== e.type) ?
4701     jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
4702     undefined;
4703   };
4704   // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
4705   eventHandle.elem = elem;
4706  }
4707
4708  // Handle multiple events separated by a space
4709  types = ( types || "" ).match( rnotwhite ) || [ "" ];
4710  t = types.length;
4711  while ( t-- ) {
4712   tmp = rtypenamespace.exec( types[t] ) || [];
4713   type = origType = tmp[1];
4714   namespaces = ( tmp[2] || "" ).split( "." ).sort();
4715
4716   // There *must* be a type, no attaching namespace-only handlers
4717   if ( !type ) {
4718    continue;
4719   }
4720
4721   // If event changes its type, use the special event handlers for the changed type
4722   special = jQuery.event.special[ type ] || {};
4723
4724   // If selector defined, determine special event api type, otherwise given type
4725   type = ( selector ? special.delegateType : special.bindType ) || type;
4726
4727   // Update special based on newly reset type
4728   special = jQuery.event.special[ type ] || {};
4729
4730   // handleObj is passed to all event handlers
4731   handleObj = jQuery.extend({
4732    type: type,
4733    origType: origType,
4734    data: data,
4735    handler: handler,
4736    guid: handler.guid,
4737    selector: selector,
4738    needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
4739    namespace: namespaces.join(".")
4740   }, handleObjIn );
4741
4742   // Init the event handler queue if we're the first
4743   if ( !(handlers = events[ type ]) ) {
4744    handlers = events[ type ] = [];
4745    handlers.delegateCount = 0;
4746
4747    // Only use addEventListener/attachEvent if the special events handler returns false
4748    if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
4749     // Bind the global event handler to the element
4750     if ( elem.addEventListener ) {
4751      elem.addEventListener( type, eventHandle, false );
4752
4753     } else if ( elem.attachEvent ) {
4754      elem.attachEvent( "on" + type, eventHandle );
4755     }
4756    }
4757   }
4758
4759   if ( special.add ) {
4760    special.add.call( elem, handleObj );
4761
4762    if ( !handleObj.handler.guid ) {
4763     handleObj.handler.guid = handler.guid;
4764    }
4765   }
4766
4767   // Add to the element's handler list, delegates in front
4768   if ( selector ) {
4769    handlers.splice( handlers.delegateCount++, 0, handleObj );
4770   } else {
4771    handlers.push( handleObj );
4772   }
4773
4774   // Keep track of which events have ever been used, for event optimization
4775   jQuery.event.global[ type ] = true;
4776  }
4777
4778  // Nullify elem to prevent memory leaks in IE
4779  elem = null;
4780 },
4781
4782 // Detach an event or set of events from an element
4783 remove: function( elem, types, handler, selector, mappedTypes ) {
4784  var j, handleObj, tmp,
4785   origCount, t, events,
4786   special, handlers, type,
4787   namespaces, origType,
4788   elemData = jQuery.hasData( elem ) && jQuery._data( elem );
4789
4790  if ( !elemData || !(events = elemData.events) ) {
4791   return;
4792  }
4793
4794  // Once for each type.namespace in types; type may be omitted
4795  types = ( types || "" ).match( rnotwhite ) || [ "" ];
4796  t = types.length;
4797  while ( t-- ) {
4798   tmp = rtypenamespace.exec( types[t] ) || [];
4799   type = origType = tmp[1];
4800   namespaces = ( tmp[2] || "" ).split( "." ).sort();
4801
4802   // Unbind all events (on this namespace, if provided) for the element
4803   if ( !type ) {
4804    for ( type in events ) {
4805     jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
4806    }
4807    continue;
4808   }
4809
4810   special = jQuery.event.special[ type ] || {};
4811   type = ( selector ? special.delegateType : special.bindType ) || type;
4812   handlers = events[ type ] || [];
4813   tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
4814
4815   // Remove matching events
4816   origCount = j = handlers.length;
4817   while ( j-- ) {
4818    handleObj = handlers[ j ];
4819
4820    if ( ( mappedTypes || origType === handleObj.origType ) &&
4821     ( !handler || handler.guid === handleObj.guid ) &&
4822     ( !tmp || tmp.test( handleObj.namespace ) ) &&
4823     ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
4824     handlers.splice( j, 1 );
4825
4826     if ( handleObj.selector ) {
4827      handlers.delegateCount--;
4828     }
4829     if ( special.remove ) {
4830      special.remove.call( elem, handleObj );
4831     }
4832    }
4833   }
4834
4835   // Remove generic event handler if we removed something and no more handlers exist
4836   // (avoids potential for endless recursion during removal of special event handlers)
4837   if ( origCount && !handlers.length ) {
4838    if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
4839     jQuery.removeEvent( elem, type, elemData.handle );
4840    }
4841
4842    delete events[ type ];
4843   }
4844  }
4845
4846  // Remove the expando if it's no longer used
4847  if ( jQuery.isEmptyObject( events ) ) {
4848   delete elemData.handle;
4849
4850   // removeData also checks for emptiness and clears the expando if empty
4851   // so use it instead of delete
4852   jQuery._removeData( elem, "events" );
4853  }
4854 },
4855
4856 trigger: function( event, data, elem, onlyHandlers ) {
4857  var handle, ontype, cur,
4858   bubbleType, special, tmp, i,
4859   eventPath = [ elem || document ],
4860   type = hasOwn.call( event, "type" ) ? event.type : event,
4861   namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
4862
4863  cur = tmp = elem = elem || document;
4864
4865  // Don't do events on text and comment nodes
4866  if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
4867   return;
4868  }
4869
4870  // focus/blur morphs to focusin/out; ensure we're not firing them right now
4871  if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
4872   return;
4873  }
4874
4875  if ( type.indexOf(".") >= 0 ) {
4876   // Namespaced trigger; create a regexp to match event type in handle()
4877   namespaces = type.split(".");
4878   type = namespaces.shift();
4879   namespaces.sort();
4880  }
4881  ontype = type.indexOf(":") < 0 && "on" + type;
4882
4883  // Caller can pass in a jQuery.Event object, Object, or just an event type string
4884  event = event[ jQuery.expando ] ?
4885   event :
4886   new jQuery.Event( type, typeof event === "object" && event );
4887
4888  // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
4889  event.isTrigger = onlyHandlers ? 2 : 3;
4890  event.namespace = namespaces.join(".");
4891  event.namespace_re = event.namespace ?
4892   new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
4893   null;
4894
4895  // Clean up the event in case it is being reused
4896  event.result = undefined;
4897  if ( !event.target ) {
4898   event.target = elem;
4899  }
4900
4901  // Clone any incoming data and prepend the event, creating the handler arg list
4902  data = data == null ?
4903   [ event ] :
4904   jQuery.makeArray( data, [ event ] );
4905
4906  // Allow special events to draw outside the lines
4907  special = jQuery.event.special[ type ] || {};
4908  if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
4909   return;
4910  }
4911
4912  // Determine event propagation path in advance, per W3C events spec (#9951)
4913  // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
4914  if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
4915
4916   bubbleType = special.delegateType || type;
4917   if ( !rfocusMorph.test( bubbleType + type ) ) {
4918    cur = cur.parentNode;
4919   }
4920   for ( ; cur; cur = cur.parentNode ) {
4921    eventPath.push( cur );
4922    tmp = cur;
4923   }
4924
4925   // Only add window if we got to document (e.g., not plain obj or detached DOM)
4926   if ( tmp === (elem.ownerDocument || document) ) {
4927    eventPath.push( tmp.defaultView || tmp.parentWindow || window );
4928   }
4929  }
4930
4931  // Fire handlers on the event path
4932  i = 0;
4933  while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
4934
4935   event.type = i > 1 ?
4936    bubbleType :
4937    special.bindType || type;
4938
4939   // jQuery handler
4940   handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
4941   if ( handle ) {
4942    handle.apply( cur, data );
4943   }
4944
4945   // Native handler
4946   handle = ontype && cur[ ontype ];
4947   if ( handle && handle.apply && jQuery.acceptData( cur ) ) {
4948    event.result = handle.apply( cur, data );
4949    if ( event.result === false ) {
4950     event.preventDefault();
4951    }
4952   }
4953  }
4954  event.type = type;
4955
4956  // If nobody prevented the default action, do it now
4957  if ( !onlyHandlers && !event.isDefaultPrevented() ) {
4958
4959   if ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) &&
4960    jQuery.acceptData( elem ) ) {
4961
4962    // Call a native DOM method on the target with the same name name as the event.
4963    // Can't use an .isFunction() check here because IE6/7 fails that test.
4964    // Don't do default actions on window, that's where global variables be (#6170)
4965    if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
4966
4967     // Don't re-trigger an onFOO event when we call its FOO() method
4968     tmp = elem[ ontype ];
4969
4970     if ( tmp ) {
4971      elem[ ontype ] = null;
4972     }
4973
4974     // Prevent re-triggering of the same event, since we already bubbled it above
4975     jQuery.event.triggered = type;
4976     try {
4977      elem[ type ]();
4978     } catch ( e ) {
4979      // IE<9 dies on focus/blur to hidden element (#1486,#12518)
4980      // only reproducible on winXP IE8 native, not IE9 in IE8 mode
4981     }
4982     jQuery.event.triggered = undefined;
4983
4984     if ( tmp ) {
4985      elem[ ontype ] = tmp;
4986     }
4987    }
4988   }
4989  }
4990
4991  return event.result;
4992 },
4993
4994 dispatch: function( event ) {
4995
4996  // Make a writable jQuery.Event from the native event object
4997  event = jQuery.event.fix( event );
4998
4999  var i, ret, handleObj, matched, j,
5000   handlerQueue = [],
5001   args = slice.call( arguments ),
5002   handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
5003   special = jQuery.event.special[ event.type ] || {};
5004
5005  // Use the fix-ed jQuery.Event rather than the (read-only) native event
5006  args[0] = event;
5007  event.delegateTarget = this;
5008
5009  // Call the preDispatch hook for the mapped type, and let it bail if desired
5010  if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
5011   return;
5012  }
5013
5014  // Determine handlers
5015  handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5016
5017  // Run delegates first; they may want to stop propagation beneath us
5018  i = 0;
5019  while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
5020   event.currentTarget = matched.elem;
5021
5022   j = 0;
5023   while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
5024
5025    // Triggered event must either 1) have no namespace, or
5026    // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
5027    if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
5028
5029     event.handleObj = handleObj;
5030     event.data = handleObj.data;
5031
5032     ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
5033       .apply( matched.elem, args );
5034
5035     if ( ret !== undefined ) {
5036      if ( (event.result = ret) === false ) {
5037       event.preventDefault();
5038       event.stopPropagation();
5039      }
5040     }
5041    }
5042   }
5043  }
5044
5045  // Call the postDispatch hook for the mapped type
5046  if ( special.postDispatch ) {
5047   special.postDispatch.call( this, event );
5048  }
5049
5050  return event.result;
5051 },
5052
5053 handlers: function( event, handlers ) {
5054  var sel, handleObj, matches, i,
5055   handlerQueue = [],
5056   delegateCount = handlers.delegateCount,
5057   cur = event.target;
5058
5059  // Find delegate handlers
5060  // Black-hole SVG <use> instance trees (#13180)
5061  // Avoid non-left-click bubbling in Firefox (#3861)
5062  if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
5063
5064   /* jshint eqeqeq: false */
5065   for ( ; cur != this; cur = cur.parentNode || this ) {
5066    /* jshint eqeqeq: true */
5067
5068    // Don't check non-elements (#13208)
5069    // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
5070    if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) {
5071     matches = [];
5072     for ( i = 0; i < delegateCount; i++ ) {
5073      handleObj = handlers[ i ];
5074
5075      // Don't conflict with Object.prototype properties (#13203)
5076      sel = handleObj.selector + " ";
5077
5078      if ( matches[ sel ] === undefined ) {
5079       matches[ sel ] = handleObj.needsContext ?
5080        jQuery( sel, this ).index( cur ) >= 0 :
5081        jQuery.find( sel, this, null, [ cur ] ).length;
5082      }
5083      if ( matches[ sel ] ) {
5084       matches.push( handleObj );
5085      }
5086     }
5087     if ( matches.length ) {
5088      handlerQueue.push({ elem: cur, handlers: matches });
5089     }
5090    }
5091   }
5092  }
5093
5094  // Add the remaining (directly-bound) handlers
5095  if ( delegateCount < handlers.length ) {
5096   handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
5097  }
5098
5099  return handlerQueue;
5100 },
5101
5102 fix: function( event ) {
5103  if ( event[ jQuery.expando ] ) {
5104   return event;
5105  }
5106
5107  // Create a writable copy of the event object and normalize some properties
5108  var i, prop, copy,
5109   type = event.type,
5110   originalEvent = event,
5111   fixHook = this.fixHooks[ type ];
5112
5113  if ( !fixHook ) {
5114   this.fixHooks[ type ] = fixHook =
5115    rmouseEvent.test( type ) ? this.mouseHooks :
5116    rkeyEvent.test( type ) ? this.keyHooks :
5117    {};
5118  }
5119  copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
5120
5121  event = new jQuery.Event( originalEvent );
5122
5123  i = copy.length;
5124  while ( i-- ) {
5125   prop = copy[ i ];
5126   event[ prop ] = originalEvent[ prop ];
5127  }
5128
5129  // Support: IE<9
5130  // Fix target property (#1925)
5131  if ( !event.target ) {
5132   event.target = originalEvent.srcElement || document;
5133  }
5134
5135  // Support: Chrome 23+, Safari?
5136  // Target should not be a text node (#504, #13143)
5137  if ( event.target.nodeType === 3 ) {
5138   event.target = event.target.parentNode;
5139  }
5140
5141  // Support: IE<9
5142  // For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
5143  event.metaKey = !!event.metaKey;
5144
5145  return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
5146 },
5147
5148 // Includes some event props shared by KeyEvent and MouseEvent
5149 props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
5150
5151 fixHooks: {},
5152
5153 keyHooks: {
5154  props: "char charCode key keyCode".split(" "),
5155  filter: function( event, original ) {
5156
5157   // Add which for key events
5158   if ( event.which == null ) {
5159    event.which = original.charCode != null ? original.charCode : original.keyCode;
5160   }
5161
5162   return event;
5163  }
5164 },
5165
5166 mouseHooks: {
5167  props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
5168  filter: function( event, original ) {
5169   var body, eventDoc, doc,
5170    button = original.button,
5171    fromElement = original.fromElement;
5172
5173   // Calculate pageX/Y if missing and clientX/Y available
5174   if ( event.pageX == null && original.clientX != null ) {
5175    eventDoc = event.target.ownerDocument || document;
5176    doc = eventDoc.documentElement;
5177    body = eventDoc.body;
5178
5179    event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
5180    event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
5181   }
5182
5183   // Add relatedTarget, if necessary
5184   if ( !event.relatedTarget && fromElement ) {
5185    event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
5186   }
5187
5188   // Add which for click: 1 === left; 2 === middle; 3 === right
5189   // Note: button is not normalized, so don't use it
5190   if ( !event.which && button !== undefined ) {
5191    event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
5192   }
5193
5194   return event;
5195  }
5196 },
5197
5198 special: {
5199  load: {
5200   // Prevent triggered image.load events from bubbling to window.load
5201   noBubble: true
5202  },
5203  focus: {
5204   // Fire native event if possible so blur/focus sequence is correct
5205   trigger: function() {
5206    if ( this !== safeActiveElement() && this.focus ) {
5207     try {
5208      this.focus();
5209      return false;
5210     } catch ( e ) {
5211      // Support: IE<9
5212      // If we error on focus to hidden element (#1486, #12518),
5213      // let .trigger() run the handlers
5214     }
5215    }
5216   },
5217   delegateType: "focusin"
5218  },
5219  blur: {
5220   trigger: function() {
5221    if ( this === safeActiveElement() && this.blur ) {
5222     this.blur();
5223     return false;
5224    }
5225   },
5226   delegateType: "focusout"
5227  },
5228  click: {
5229   // For checkbox, fire native event so checked state will be right
5230   trigger: function() {
5231    if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
5232     this.click();
5233     return false;
5234    }
5235   },
5236
5237   // For cross-browser consistency, don't fire native .click() on links
5238   _default: function( event ) {
5239    return jQuery.nodeName( event.target, "a" );
5240   }
5241  },
5242
5243  beforeunload: {
5244   postDispatch: function( event ) {
5245
5246    // Support: Firefox 20+
5247    // Firefox doesn't alert if the returnValue field is not set.
5248    if ( event.result !== undefined && event.originalEvent ) {
5249     event.originalEvent.returnValue = event.result;
5250    }
5251   }
5252  }
5253 },
5254
5255 simulate: function( type, elem, event, bubble ) {
5256  // Piggyback on a donor event to simulate a different one.
5257  // Fake originalEvent to avoid donor's stopPropagation, but if the
5258  // simulated event prevents default then we do the same on the donor.
5259  var e = jQuery.extend(
5260   new jQuery.Event(),
5261   event,
5262   {
5263    type: type,
5264    isSimulated: true,
5265    originalEvent: {}
5266   }
5267  );
5268  if ( bubble ) {
5269   jQuery.event.trigger( e, null, elem );
5270  } else {
5271   jQuery.event.dispatch.call( elem, e );
5272  }
5273  if ( e.isDefaultPrevented() ) {
5274   event.preventDefault();
5275  }
5276 }
5277};
5278
5279jQuery.removeEvent = document.removeEventListener ?
5280 function( elem, type, handle ) {
5281  if ( elem.removeEventListener ) {
5282   elem.removeEventListener( type, handle, false );
5283  }
5284 } :
5285 function( elem, type, handle ) {
5286  var name = "on" + type;
5287
5288  if ( elem.detachEvent ) {
5289
5290   // #8545, #7054, preventing memory leaks for custom events in IE6-8
5291   // detachEvent needed property on element, by name of that event, to properly expose it to GC
5292   if ( typeof elem[ name ] === strundefined ) {
5293    elem[ name ] = null;
5294   }
5295
5296   elem.detachEvent( name, handle );
5297  }
5298 };
5299
5300jQuery.Event = function( src, props ) {
5301 // Allow instantiation without the 'new' keyword
5302 if ( !(this instanceof jQuery.Event) ) {
5303  return new jQuery.Event( src, props );
5304 }
5305
5306 // Event object
5307 if ( src && src.type ) {
5308  this.originalEvent = src;
5309  this.type = src.type;
5310
5311  // Events bubbling up the document may have been marked as prevented
5312  // by a handler lower down the tree; reflect the correct value.
5313  this.isDefaultPrevented = src.defaultPrevented ||
5314    src.defaultPrevented === undefined &&
5315    // Support: IE < 9, Android < 4.0
5316    src.returnValue === false ?
5317   returnTrue :
5318   returnFalse;
5319
5320 // Event type
5321 } else {
5322  this.type = src;
5323 }
5324
5325 // Put explicitly provided properties onto the event object
5326 if ( props ) {
5327  jQuery.extend( this, props );
5328 }
5329
5330 // Create a timestamp if incoming event doesn't have one
5331 this.timeStamp = src && src.timeStamp || jQuery.now();
5332
5333 // Mark it as fixed
5334 this[ jQuery.expando ] = true;
5335};
5336
5337// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5338// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5339jQuery.Event.prototype = {
5340 isDefaultPrevented: returnFalse,
5341 isPropagationStopped: returnFalse,
5342 isImmediatePropagationStopped: returnFalse,
5343
5344 preventDefault: function() {
5345  var e = this.originalEvent;
5346
5347  this.isDefaultPrevented = returnTrue;
5348  if ( !e ) {
5349   return;
5350  }
5351
5352  // If preventDefault exists, run it on the original event
5353  if ( e.preventDefault ) {
5354   e.preventDefault();
5355
5356  // Support: IE
5357  // Otherwise set the returnValue property of the original event to false
5358  } else {
5359   e.returnValue = false;
5360  }
5361 },
5362 stopPropagation: function() {
5363  var e = this.originalEvent;
5364
5365  this.isPropagationStopped = returnTrue;
5366  if ( !e ) {
5367   return;
5368  }
5369  // If stopPropagation exists, run it on the original event
5370  if ( e.stopPropagation ) {
5371   e.stopPropagation();
5372  }
5373
5374  // Support: IE
5375  // Set the cancelBubble property of the original event to true
5376  e.cancelBubble = true;
5377 },
5378 stopImmediatePropagation: function() {
5379  var e = this.originalEvent;
5380
5381  this.isImmediatePropagationStopped = returnTrue;
5382
5383  if ( e && e.stopImmediatePropagation ) {
5384   e.stopImmediatePropagation();
5385  }
5386
5387  this.stopPropagation();
5388 }
5389};
5390
5391// Create mouseenter/leave events using mouseover/out and event-time checks
5392jQuery.each({
5393 mouseenter: "mouseover",
5394 mouseleave: "mouseout",
5395 pointerenter: "pointerover",
5396 pointerleave: "pointerout"
5397}, function( orig, fix ) {
5398 jQuery.event.special[ orig ] = {
5399  delegateType: fix,
5400  bindType: fix,
5401
5402  handle: function( event ) {
5403   var ret,
5404    target = this,
5405    related = event.relatedTarget,
5406    handleObj = event.handleObj;
5407
5408   // For mousenter/leave call the handler if related is outside the target.
5409   // NB: No relatedTarget if the mouse left/entered the browser window
5410   if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
5411    event.type = handleObj.origType;
5412    ret = handleObj.handler.apply( this, arguments );
5413    event.type = fix;
5414   }
5415   return ret;
5416  }
5417 };
5418});
5419
5420// IE submit delegation
5421if ( !support.submitBubbles ) {
5422
5423 jQuery.event.special.submit = {
5424  setup: function() {
5425   // Only need this for delegated form submit events
5426   if ( jQuery.nodeName( this, "form" ) ) {
5427    return false;
5428   }
5429
5430   // Lazy-add a submit handler when a descendant form may potentially be submitted
5431   jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
5432    // Node name check avoids a VML-related crash in IE (#9807)
5433    var elem = e.target,
5434     form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
5435    if ( form && !jQuery._data( form, "submitBubbles" ) ) {
5436     jQuery.event.add( form, "submit._submit", function( event ) {
5437      event._submit_bubble = true;
5438     });
5439     jQuery._data( form, "submitBubbles", true );
5440    }
5441   });
5442   // return undefined since we don't need an event listener
5443  },
5444
5445  postDispatch: function( event ) {
5446   // If form was submitted by the user, bubble the event up the tree
5447   if ( event._submit_bubble ) {
5448    delete event._submit_bubble;
5449    if ( this.parentNode && !event.isTrigger ) {
5450     jQuery.event.simulate( "submit", this.parentNode, event, true );
5451    }
5452   }
5453  },
5454
5455  teardown: function() {
5456   // Only need this for delegated form submit events
5457   if ( jQuery.nodeName( this, "form" ) ) {
5458    return false;
5459   }
5460
5461   // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
5462   jQuery.event.remove( this, "._submit" );
5463  }
5464 };
5465}
5466
5467// IE change delegation and checkbox/radio fix
5468if ( !support.changeBubbles ) {
5469
5470 jQuery.event.special.change = {
5471
5472  setup: function() {
5473
5474   if ( rformElems.test( this.nodeName ) ) {
5475    // IE doesn't fire change on a check/radio until blur; trigger it on click
5476    // after a propertychange. Eat the blur-change in special.change.handle.
5477    // This still fires onchange a second time for check/radio after blur.
5478    if ( this.type === "checkbox" || this.type === "radio" ) {
5479     jQuery.event.add( this, "propertychange._change", function( event ) {
5480      if ( event.originalEvent.propertyName === "checked" ) {
5481       this._just_changed = true;
5482      }
5483     });
5484     jQuery.event.add( this, "click._change", function( event ) {
5485      if ( this._just_changed && !event.isTrigger ) {
5486       this._just_changed = false;
5487      }
5488      // Allow triggered, simulated change events (#11500)
5489      jQuery.event.simulate( "change", this, event, true );
5490     });
5491    }
5492    return false;
5493   }
5494   // Delegated event; lazy-add a change handler on descendant inputs
5495   jQuery.event.add( this, "beforeactivate._change", function( e ) {
5496    var elem = e.target;
5497
5498    if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) {
5499     jQuery.event.add( elem, "change._change", function( event ) {
5500      if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
5501       jQuery.event.simulate( "change", this.parentNode, event, true );
5502      }
5503     });
5504     jQuery._data( elem, "changeBubbles", true );
5505    }
5506   });
5507  },
5508
5509  handle: function( event ) {
5510   var elem = event.target;
5511
5512   // Swallow native change events from checkbox/radio, we already triggered them above
5513   if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
5514    return event.handleObj.handler.apply( this, arguments );
5515   }
5516  },
5517
5518  teardown: function() {
5519   jQuery.event.remove( this, "._change" );
5520
5521   return !rformElems.test( this.nodeName );
5522  }
5523 };
5524}
5525
5526// Create "bubbling" focus and blur events
5527if ( !support.focusinBubbles ) {
5528 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
5529
5530  // Attach a single capturing handler on the document while someone wants focusin/focusout
5531  var handler = function( event ) {
5532    jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
5533   };
5534
5535  jQuery.event.special[ fix ] = {
5536   setup: function() {
5537    var doc = this.ownerDocument || this,
5538     attaches = jQuery._data( doc, fix );
5539
5540    if ( !attaches ) {
5541     doc.addEventListener( orig, handler, true );
5542    }
5543    jQuery._data( doc, fix, ( attaches || 0 ) + 1 );
5544   },
5545   teardown: function() {
5546    var doc = this.ownerDocument || this,
5547     attaches = jQuery._data( doc, fix ) - 1;
5548
5549    if ( !attaches ) {
5550     doc.removeEventListener( orig, handler, true );
5551     jQuery._removeData( doc, fix );
5552    } else {
5553     jQuery._data( doc, fix, attaches );
5554    }
5555   }
5556  };
5557 });
5558}
5559
5560jQuery.fn.extend({
5561
5562 on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
5563  var type, origFn;
5564
5565  // Types can be a map of types/handlers
5566  if ( typeof types === "object" ) {
5567   // ( types-Object, selector, data )
5568   if ( typeof selector !== "string" ) {
5569    // ( types-Object, data )
5570    data = data || selector;
5571    selector = undefined;
5572   }
5573   for ( type in types ) {
5574    this.on( type, selector, data, types[ type ], one );
5575   }
5576   return this;
5577  }
5578
5579  if ( data == null && fn == null ) {
5580   // ( types, fn )
5581   fn = selector;
5582   data = selector = undefined;
5583  } else if ( fn == null ) {
5584   if ( typeof selector === "string" ) {
5585    // ( types, selector, fn )
5586    fn = data;
5587    data = undefined;
5588   } else {
5589    // ( types, data, fn )
5590    fn = data;
5591    data = selector;
5592    selector = undefined;
5593   }
5594  }
5595  if ( fn === false ) {
5596   fn = returnFalse;
5597  } else if ( !fn ) {
5598   return this;
5599  }
5600
5601  if ( one === 1 ) {
5602   origFn = fn;
5603   fn = function( event ) {
5604    // Can use an empty set, since event contains the info
5605    jQuery().off( event );
5606    return origFn.apply( this, arguments );
5607   };
5608   // Use same guid so caller can remove using origFn
5609   fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
5610  }
5611  return this.each( function() {
5612   jQuery.event.add( this, types, fn, data, selector );
5613  });
5614 },
5615 one: function( types, selector, data, fn ) {
5616  return this.on( types, selector, data, fn, 1 );
5617 },
5618 off: function( types, selector, fn ) {
5619  var handleObj, type;
5620  if ( types && types.preventDefault && types.handleObj ) {
5621   // ( event )  dispatched jQuery.Event
5622   handleObj = types.handleObj;
5623   jQuery( types.delegateTarget ).off(
5624    handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
5625    handleObj.selector,
5626    handleObj.handler
5627   );
5628   return this;
5629  }
5630  if ( typeof types === "object" ) {
5631   // ( types-object [, selector] )
5632   for ( type in types ) {
5633    this.off( type, selector, types[ type ] );
5634   }
5635   return this;
5636  }
5637  if ( selector === false || typeof selector === "function" ) {
5638   // ( types [, fn] )
5639   fn = selector;
5640   selector = undefined;
5641  }
5642  if ( fn === false ) {
5643   fn = returnFalse;
5644  }
5645  return this.each(function() {
5646   jQuery.event.remove( this, types, fn, selector );
5647  });
5648 },
5649
5650 trigger: function( type, data ) {
5651  return this.each(function() {
5652   jQuery.event.trigger( type, data, this );
5653  });
5654 },
5655 triggerHandler: function( type, data ) {
5656  var elem = this[0];
5657  if ( elem ) {
5658   return jQuery.event.trigger( type, data, elem, true );
5659  }
5660 }
5661});
5662
5663function createSafeFragment( document ) {
5664 var list = nodeNames.split( "|" ),
5665  safeFrag = document.createDocumentFragment();
5666
5667 if ( safeFrag.createElement ) {
5668  while ( list.length ) {
5669   safeFrag.createElement(
5670    list.pop()
5671   );
5672  }
5673 }
5674 return safeFrag;
5675}
5676
5677var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
5678  "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
5679 rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
5680 rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
5681 rleadingWhitespace = /^\s+/,
5682 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
5683 rtagName = /<([\w:]+)/,
5684 rtbody = /<tbody/i,
5685 rhtml = /<|&#?\w+;/,
5686 rnoInnerhtml = /<(?:script|style|link)/i,
5687 // checked="checked" or checked
5688 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5689 rscriptType = /^$|\/(?:java|ecma)script/i,
5690 rscriptTypeMasked = /^true\/(.*)/,
5691 rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
5692
5693 // We have to close these tags to support XHTML (#13200)
5694 wrapMap = {
5695  option: [ 1, "<select multiple='multiple'>", "</select>" ],
5696  legend: [ 1, "<fieldset>", "</fieldset>" ],
5697  area: [ 1, "<map>", "</map>" ],
5698  param: [ 1, "<object>", "</object>" ],
5699  thead: [ 1, "<table>", "</table>" ],
5700  tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5701  col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5702  td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5703
5704  // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
5705  // unless wrapped in a div with non-breaking characters in front of it.
5706  _default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>"  ]
5707 },
5708 safeFragment = createSafeFragment( document ),
5709 fragmentDiv = safeFragment.appendChild( document.createElement("div") );
5710
5711wrapMap.optgroup = wrapMap.option;
5712wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5713wrapMap.th = wrapMap.td;
5714
5715function getAll( context, tag ) {
5716 var elems, elem,
5717  i = 0,
5718  found = typeof context.getElementsByTagName !== strundefined ? context.getElementsByTagName( tag || "*" ) :
5719   typeof context.querySelectorAll !== strundefined ? context.querySelectorAll( tag || "*" ) :
5720   undefined;
5721
5722 if ( !found ) {
5723  for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {
5724   if ( !tag || jQuery.nodeName( elem, tag ) ) {
5725    found.push( elem );
5726   } else {
5727    jQuery.merge( found, getAll( elem, tag ) );
5728   }
5729  }
5730 }
5731
5732 return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
5733  jQuery.merge( [ context ], found ) :
5734  found;
5735}
5736
5737// Used in buildFragment, fixes the defaultChecked property
5738function fixDefaultChecked( elem ) {
5739 if ( rcheckableType.test( elem.type ) ) {
5740  elem.defaultChecked = elem.checked;
5741 }
5742}
5743
5744// Support: IE<8
5745// Manipulating tables requires a tbody
5746function manipulationTarget( elem, content ) {
5747 return jQuery.nodeName( elem, "table" ) &&
5748  jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
5749
5750  elem.getElementsByTagName("tbody")[0] ||
5751   elem.appendChild( elem.ownerDocument.createElement("tbody") ) :
5752  elem;
5753}
5754
5755// Replace/restore the type attribute of script elements for safe DOM manipulation
5756function disableScript( elem ) {
5757 elem.type = (jQuery.find.attr( elem, "type" ) !== null) + "/" + elem.type;
5758 return elem;
5759}
5760function restoreScript( elem ) {
5761 var match = rscriptTypeMasked.exec( elem.type );
5762 if ( match ) {
5763  elem.type = match[1];
5764 } else {
5765  elem.removeAttribute("type");
5766 }
5767 return elem;
5768}
5769
5770// Mark scripts as having already been evaluated
5771function setGlobalEval( elems, refElements ) {
5772 var elem,
5773  i = 0;
5774 for ( ; (elem = elems[i]) != null; i++ ) {
5775  jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) );
5776 }
5777}
5778
5779function cloneCopyEvent( src, dest ) {
5780
5781 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
5782  return;
5783 }
5784
5785 var type, i, l,
5786  oldData = jQuery._data( src ),
5787  curData = jQuery._data( dest, oldData ),
5788  events = oldData.events;
5789
5790 if ( events ) {
5791  delete curData.handle;
5792  curData.events = {};
5793
5794  for ( type in events ) {
5795   for ( i = 0, l = events[ type ].length; i < l; i++ ) {
5796    jQuery.event.add( dest, type, events[ type ][ i ] );
5797   }
5798  }
5799 }
5800
5801 // make the cloned public data object a copy from the original
5802 if ( curData.data ) {
5803  curData.data = jQuery.extend( {}, curData.data );
5804 }
5805}
5806
5807function fixCloneNodeIssues( src, dest ) {
5808 var nodeName, e, data;
5809
5810 // We do not need to do anything for non-Elements
5811 if ( dest.nodeType !== 1 ) {
5812  return;
5813 }
5814
5815 nodeName = dest.nodeName.toLowerCase();
5816
5817 // IE6-8 copies events bound via attachEvent when using cloneNode.
5818 if ( !support.noCloneEvent && dest[ jQuery.expando ] ) {
5819  data = jQuery._data( dest );
5820
5821  for ( e in data.events ) {
5822   jQuery.removeEvent( dest, e, data.handle );
5823  }
5824
5825  // Event data gets referenced instead of copied if the expando gets copied too
5826  dest.removeAttribute( jQuery.expando );
5827 }
5828
5829 // IE blanks contents when cloning scripts, and tries to evaluate newly-set text
5830 if ( nodeName === "script" && dest.text !== src.text ) {
5831  disableScript( dest ).text = src.text;
5832  restoreScript( dest );
5833
5834 // IE6-10 improperly clones children of object elements using classid.
5835 // IE10 throws NoModificationAllowedError if parent is null, #12132.
5836 } else if ( nodeName === "object" ) {
5837  if ( dest.parentNode ) {
5838   dest.outerHTML = src.outerHTML;
5839  }
5840
5841  // This path appears unavoidable for IE9. When cloning an object
5842  // element in IE9, the outerHTML strategy above is not sufficient.
5843  // If the src has innerHTML and the destination does not,
5844  // copy the src.innerHTML into the dest.innerHTML. #10324
5845  if ( support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {
5846   dest.innerHTML = src.innerHTML;
5847  }
5848
5849 } else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
5850  // IE6-8 fails to persist the checked state of a cloned checkbox
5851  // or radio button. Worse, IE6-7 fail to give the cloned element
5852  // a checked appearance if the defaultChecked value isn't also set
5853
5854  dest.defaultChecked = dest.checked = src.checked;
5855
5856  // IE6-7 get confused and end up setting the value of a cloned
5857  // checkbox/radio button to an empty string instead of "on"
5858  if ( dest.value !== src.value ) {
5859   dest.value = src.value;
5860  }
5861
5862 // IE6-8 fails to return the selected option to the default selected
5863 // state when cloning options
5864 } else if ( nodeName === "option" ) {
5865  dest.defaultSelected = dest.selected = src.defaultSelected;
5866
5867 // IE6-8 fails to set the defaultValue to the correct value when
5868 // cloning other types of input fields
5869 } else if ( nodeName === "input" || nodeName === "textarea" ) {
5870  dest.defaultValue = src.defaultValue;
5871 }
5872}
5873
5874jQuery.extend({
5875 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5876  var destElements, node, clone, i, srcElements,
5877   inPage = jQuery.contains( elem.ownerDocument, elem );
5878
5879  if ( support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
5880   clone = elem.cloneNode( true );
5881
5882  // IE<=8 does not properly clone detached, unknown element nodes
5883  } else {
5884   fragmentDiv.innerHTML = elem.outerHTML;
5885   fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
5886  }
5887
5888  if ( (!support.noCloneEvent || !support.noCloneChecked) &&
5889    (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
5890
5891   // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
5892   destElements = getAll( clone );
5893   srcElements = getAll( elem );
5894
5895   // Fix all IE cloning issues
5896   for ( i = 0; (node = srcElements[i]) != null; ++i ) {
5897    // Ensure that the destination node is not null; Fixes #9587
5898    if ( destElements[i] ) {
5899     fixCloneNodeIssues( node, destElements[i] );
5900    }
5901   }
5902  }
5903
5904  // Copy the events from the original to the clone
5905  if ( dataAndEvents ) {
5906   if ( deepDataAndEvents ) {
5907    srcElements = srcElements || getAll( elem );
5908    destElements = destElements || getAll( clone );
5909
5910    for ( i = 0; (node = srcElements[i]) != null; i++ ) {
5911     cloneCopyEvent( node, destElements[i] );
5912    }
5913   } else {
5914    cloneCopyEvent( elem, clone );
5915   }
5916  }
5917
5918  // Preserve script evaluation history
5919  destElements = getAll( clone, "script" );
5920  if ( destElements.length > 0 ) {
5921   setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
5922  }
5923
5924  destElements = srcElements = node = null;
5925
5926  // Return the cloned set
5927  return clone;
5928 },
5929
5930 buildFragment: function( elems, context, scripts, selection ) {
5931  var j, elem, contains,
5932   tmp, tag, tbody, wrap,
5933   l = elems.length,
5934
5935   // Ensure a safe fragment
5936   safe = createSafeFragment( context ),
5937
5938   nodes = [],
5939   i = 0;
5940
5941  for ( ; i < l; i++ ) {
5942   elem = elems[ i ];
5943
5944   if ( elem || elem === 0 ) {
5945
5946    // Add nodes directly
5947    if ( jQuery.type( elem ) === "object" ) {
5948     jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
5949
5950    // Convert non-html into a text node
5951    } else if ( !rhtml.test( elem ) ) {
5952     nodes.push( context.createTextNode( elem ) );
5953
5954    // Convert html into DOM nodes
5955    } else {
5956     tmp = tmp || safe.appendChild( context.createElement("div") );
5957
5958     // Deserialize a standard representation
5959     tag = (rtagName.exec( elem ) || [ "", "" ])[ 1 ].toLowerCase();
5960     wrap = wrapMap[ tag ] || wrapMap._default;
5961
5962     tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2];
5963
5964     // Descend through wrappers to the right content
5965     j = wrap[0];
5966     while ( j-- ) {
5967      tmp = tmp.lastChild;
5968     }
5969
5970     // Manually add leading whitespace removed by IE
5971     if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
5972      nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
5973     }
5974
5975     // Remove IE's autoinserted <tbody> from table fragments
5976     if ( !support.tbody ) {
5977
5978      // String was a <table>, *may* have spurious <tbody>
5979      elem = tag === "table" && !rtbody.test( elem ) ?
5980       tmp.firstChild :
5981
5982       // String was a bare <thead> or <tfoot>
5983       wrap[1] === "<table>" && !rtbody.test( elem ) ?
5984        tmp :
5985        0;
5986
5987      j = elem && elem.childNodes.length;
5988      while ( j-- ) {
5989       if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) {
5990        elem.removeChild( tbody );
5991       }
5992      }
5993     }
5994
5995     jQuery.merge( nodes, tmp.childNodes );
5996
5997     // Fix #12392 for WebKit and IE > 9
5998     tmp.textContent = "";
5999
6000     // Fix #12392 for oldIE
6001     while ( tmp.firstChild ) {
6002      tmp.removeChild( tmp.firstChild );
6003     }
6004
6005     // Remember the top-level container for proper cleanup
6006     tmp = safe.lastChild;
6007    }
6008   }
6009  }
6010
6011  // Fix #11356: Clear elements from fragment
6012  if ( tmp ) {
6013   safe.removeChild( tmp );
6014  }
6015
6016  // Reset defaultChecked for any radios and checkboxes
6017  // about to be appended to the DOM in IE 6/7 (#8060)
6018  if ( !support.appendChecked ) {
6019   jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
6020  }
6021
6022  i = 0;
6023  while ( (elem = nodes[ i++ ]) ) {
6024
6025   // #4087 - If origin and destination elements are the same, and this is
6026   // that element, do not do anything
6027   if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
6028    continue;
6029   }
6030
6031   contains = jQuery.contains( elem.ownerDocument, elem );
6032
6033   // Append to fragment
6034   tmp = getAll( safe.appendChild( elem ), "script" );
6035
6036   // Preserve script evaluation history
6037   if ( contains ) {
6038    setGlobalEval( tmp );
6039   }
6040
6041   // Capture executables
6042   if ( scripts ) {
6043    j = 0;
6044    while ( (elem = tmp[ j++ ]) ) {
6045     if ( rscriptType.test( elem.type || "" ) ) {
6046      scripts.push( elem );
6047     }
6048    }
6049   }
6050  }
6051
6052  tmp = null;
6053
6054  return safe;
6055 },
6056
6057 cleanData: function( elems, /* internal */ acceptData ) {
6058  var elem, type, id, data,
6059   i = 0,
6060   internalKey = jQuery.expando,
6061   cache = jQuery.cache,
6062   deleteExpando = support.deleteExpando,
6063   special = jQuery.event.special;
6064
6065  for ( ; (elem = elems[i]) != null; i++ ) {
6066   if ( acceptData || jQuery.acceptData( elem ) ) {
6067
6068    id = elem[ internalKey ];
6069    data = id && cache[ id ];
6070
6071    if ( data ) {
6072     if ( data.events ) {
6073      for ( type in data.events ) {
6074       if ( special[ type ] ) {
6075        jQuery.event.remove( elem, type );
6076
6077       // This is a shortcut to avoid jQuery.event.remove's overhead
6078       } else {
6079        jQuery.removeEvent( elem, type, data.handle );
6080       }
6081      }
6082     }
6083
6084     // Remove cache only if it was not already removed by jQuery.event.remove
6085     if ( cache[ id ] ) {
6086
6087      delete cache[ id ];
6088
6089      // IE does not allow us to delete expando properties from nodes,
6090      // nor does it have a removeAttribute function on Document nodes;
6091      // we must handle all of these cases
6092      if ( deleteExpando ) {
6093       delete elem[ internalKey ];
6094
6095      } else if ( typeof elem.removeAttribute !== strundefined ) {
6096       elem.removeAttribute( internalKey );
6097
6098      } else {
6099       elem[ internalKey ] = null;
6100      }
6101
6102      deletedIds.push( id );
6103     }
6104    }
6105   }
6106  }
6107 }
6108});
6109
6110jQuery.fn.extend({
6111 text: function( value ) {
6112  return access( this, function( value ) {
6113   return value === undefined ?
6114    jQuery.text( this ) :
6115    this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
6116  }, null, value, arguments.length );
6117 },
6118
6119 append: function() {
6120  return this.domManip( arguments, function( elem ) {
6121   if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6122    var target = manipulationTarget( this, elem );
6123    target.appendChild( elem );
6124   }
6125  });
6126 },
6127
6128 prepend: function() {
6129  return this.domManip( arguments, function( elem ) {
6130   if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6131    var target = manipulationTarget( this, elem );
6132    target.insertBefore( elem, target.firstChild );
6133   }
6134  });
6135 },
6136
6137 before: function() {
6138  return this.domManip( arguments, function( elem ) {
6139   if ( this.parentNode ) {
6140    this.parentNode.insertBefore( elem, this );
6141   }
6142  });
6143 },
6144
6145 after: function() {
6146  return this.domManip( arguments, function( elem ) {
6147   if ( this.parentNode ) {
6148    this.parentNode.insertBefore( elem, this.nextSibling );
6149   }
6150  });
6151 },
6152
6153 remove: function( selector, keepData /* Internal Use Only */ ) {
6154  var elem,
6155   elems = selector ? jQuery.filter( selector, this ) : this,
6156   i = 0;
6157
6158  for ( ; (elem = elems[i]) != null; i++ ) {
6159
6160   if ( !keepData && elem.nodeType === 1 ) {
6161    jQuery.cleanData( getAll( elem ) );
6162   }
6163
6164   if ( elem.parentNode ) {
6165    if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
6166     setGlobalEval( getAll( elem, "script" ) );
6167    }
6168    elem.parentNode.removeChild( elem );
6169   }
6170  }
6171
6172  return this;
6173 },
6174
6175 empty: function() {
6176  var elem,
6177   i = 0;
6178
6179  for ( ; (elem = this[i]) != null; i++ ) {
6180   // Remove element nodes and prevent memory leaks
6181   if ( elem.nodeType === 1 ) {
6182    jQuery.cleanData( getAll( elem, false ) );
6183   }
6184
6185   // Remove any remaining nodes
6186   while ( elem.firstChild ) {
6187    elem.removeChild( elem.firstChild );
6188   }
6189
6190   // If this is a select, ensure that it displays empty (#12336)
6191   // Support: IE<9
6192   if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
6193    elem.options.length = 0;
6194   }
6195  }
6196
6197  return this;
6198 },
6199
6200 clone: function( dataAndEvents, deepDataAndEvents ) {
6201  dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
6202  deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
6203
6204  return this.map(function() {
6205   return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
6206  });
6207 },
6208
6209 html: function( value ) {
6210  return access( this, function( value ) {
6211   var elem = this[ 0 ] || {},
6212    i = 0,
6213    l = this.length;
6214
6215   if ( value === undefined ) {
6216    return elem.nodeType === 1 ?
6217     elem.innerHTML.replace( rinlinejQuery, "" ) :
6218     undefined;
6219   }
6220
6221   // See if we can take a shortcut and just use innerHTML
6222   if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
6223    ( support.htmlSerialize || !rnoshimcache.test( value )  ) &&
6224    ( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
6225    !wrapMap[ (rtagName.exec( value ) || [ "", "" ])[ 1 ].toLowerCase() ] ) {
6226
6227    value = value.replace( rxhtmlTag, "<$1></$2>" );
6228
6229    try {
6230     for (; i < l; i++ ) {
6231      // Remove element nodes and prevent memory leaks
6232      elem = this[i] || {};
6233      if ( elem.nodeType === 1 ) {
6234       jQuery.cleanData( getAll( elem, false ) );
6235       elem.innerHTML = value;
6236      }
6237     }
6238
6239     elem = 0;
6240
6241    // If using innerHTML throws an exception, use the fallback method
6242    } catch(e) {}
6243   }
6244
6245   if ( elem ) {
6246    this.empty().append( value );
6247   }
6248  }, null, value, arguments.length );
6249 },
6250
6251 replaceWith: function() {
6252  var arg = arguments[ 0 ];
6253
6254  // Make the changes, replacing each context element with the new content
6255  this.domManip( arguments, function( elem ) {
6256   arg = this.parentNode;
6257
6258   jQuery.cleanData( getAll( this ) );
6259
6260   if ( arg ) {
6261    arg.replaceChild( elem, this );
6262   }
6263  });
6264
6265  // Force removal if there was no new content (e.g., from empty arguments)
6266  return arg && (arg.length || arg.nodeType) ? this : this.remove();
6267 },
6268
6269 detach: function( selector ) {
6270  return this.remove( selector, true );
6271 },
6272
6273 domManip: function( args, callback ) {
6274
6275  // Flatten any nested arrays
6276  args = concat.apply( [], args );
6277
6278  var first, node, hasScripts,
6279   scripts, doc, fragment,
6280   i = 0,
6281   l = this.length,
6282   set = this,
6283   iNoClone = l - 1,
6284   value = args[0],
6285   isFunction = jQuery.isFunction( value );
6286
6287  // We can't cloneNode fragments that contain checked, in WebKit
6288  if ( isFunction ||
6289    ( l > 1 && typeof value === "string" &&
6290     !support.checkClone && rchecked.test( value ) ) ) {
6291   return this.each(function( index ) {
6292    var self = set.eq( index );
6293    if ( isFunction ) {
6294     args[0] = value.call( this, index, self.html() );
6295    }
6296    self.domManip( args, callback );
6297   });
6298  }
6299
6300  if ( l ) {
6301   fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
6302   first = fragment.firstChild;
6303
6304   if ( fragment.childNodes.length === 1 ) {
6305    fragment = first;
6306   }
6307
6308   if ( first ) {
6309    scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
6310    hasScripts = scripts.length;
6311
6312    // Use the original fragment for the last item instead of the first because it can end up
6313    // being emptied incorrectly in certain situations (#8070).
6314    for ( ; i < l; i++ ) {
6315     node = fragment;
6316
6317     if ( i !== iNoClone ) {
6318      node = jQuery.clone( node, true, true );
6319
6320      // Keep references to cloned scripts for later restoration
6321      if ( hasScripts ) {
6322       jQuery.merge( scripts, getAll( node, "script" ) );
6323      }
6324     }
6325
6326     callback.call( this[i], node, i );
6327    }
6328
6329    if ( hasScripts ) {
6330     doc = scripts[ scripts.length - 1 ].ownerDocument;
6331
6332     // Reenable scripts
6333     jQuery.map( scripts, restoreScript );
6334
6335     // Evaluate executable scripts on first document insertion
6336     for ( i = 0; i < hasScripts; i++ ) {
6337      node = scripts[ i ];
6338      if ( rscriptType.test( node.type || "" ) &&
6339       !jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
6340
6341       if ( node.src ) {
6342        // Optional AJAX dependency, but won't run scripts if not present
6343        if ( jQuery._evalUrl ) {
6344         jQuery._evalUrl( node.src );
6345        }
6346       } else {
6347        jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) );
6348       }
6349      }
6350     }
6351    }
6352
6353    // Fix #11809: Avoid leaking memory
6354    fragment = first = null;
6355   }
6356  }
6357
6358  return this;
6359 }
6360});
6361
6362jQuery.each({
6363 appendTo: "append",
6364 prependTo: "prepend",
6365 insertBefore: "before",
6366 insertAfter: "after",
6367 replaceAll: "replaceWith"
6368}, function( name, original ) {
6369 jQuery.fn[ name ] = function( selector ) {
6370  var elems,
6371   i = 0,
6372   ret = [],
6373   insert = jQuery( selector ),
6374   last = insert.length - 1;
6375
6376  for ( ; i <= last; i++ ) {
6377   elems = i === last ? this : this.clone(true);
6378   jQuery( insert[i] )[ original ]( elems );
6379
6380   // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
6381   push.apply( ret, elems.get() );
6382  }
6383
6384  return this.pushStack( ret );
6385 };
6386});
6387
6388var iframe,
6389 elemdisplay = {};
6390
6391/**
6392 * Retrieve the actual display of a element
6393 * @param {String} name nodeName of the element
6394 * @param {Object} doc Document object
6395 */
6396// Called only from within defaultDisplay
6397function actualDisplay( name, doc ) {
6398 var style,
6399  elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
6400
6401  // getDefaultComputedStyle might be reliably used only on attached element
6402  display = window.getDefaultComputedStyle && ( style = window.getDefaultComputedStyle( elem[ 0 ] ) ) ?
6403
6404   // Use of this method is a temporary fix (more like optmization) until something better comes along,
6405   // since it was removed from specification and supported only in FF
6406   style.display : jQuery.css( elem[ 0 ], "display" );
6407
6408 // We don't have any data stored on the element,
6409 // so use "detach" method as fast way to get rid of the element
6410 elem.detach();
6411
6412 return display;
6413}
6414
6415/**
6416 * Try to determine the default display value of an element
6417 * @param {String} nodeName
6418 */
6419function defaultDisplay( nodeName ) {
6420 var doc = document,
6421  display = elemdisplay[ nodeName ];
6422
6423 if ( !display ) {
6424  display = actualDisplay( nodeName, doc );
6425
6426  // If the simple way fails, read from inside an iframe
6427  if ( display === "none" || !display ) {
6428
6429   // Use the already-created iframe if possible
6430   iframe = (iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" )).appendTo( doc.documentElement );
6431
6432   // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
6433   doc = ( iframe[ 0 ].contentWindow || iframe[ 0 ].contentDocument ).document;
6434
6435   // Support: IE
6436   doc.write();
6437   doc.close();
6438
6439   display = actualDisplay( nodeName, doc );
6440   iframe.detach();
6441  }
6442
6443  // Store the correct default display
6444  elemdisplay[ nodeName ] = display;
6445 }
6446
6447 return display;
6448}
6449
6450(function() {
6451 var shrinkWrapBlocksVal;
6452
6453 support.shrinkWrapBlocks = function() {
6454  if ( shrinkWrapBlocksVal != null ) {
6455   return shrinkWrapBlocksVal;
6456  }
6457
6458  // Will be changed later if needed.
6459  shrinkWrapBlocksVal = false;
6460
6461  // Minified: var b,c,d
6462  var div, body, container;
6463
6464  body = document.getElementsByTagName( "body" )[ 0 ];
6465  if ( !body || !body.style ) {
6466   // Test fired too early or in an unsupported environment, exit.
6467   return;
6468  }
6469
6470  // Setup
6471  div = document.createElement( "div" );
6472  container = document.createElement( "div" );
6473  container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
6474  body.appendChild( container ).appendChild( div );
6475
6476  // Support: IE6
6477  // Check if elements with layout shrink-wrap their children
6478  if ( typeof div.style.zoom !== strundefined ) {
6479   // Reset CSS: box-sizing; display; margin; border
6480   div.style.cssText =
6481    // Support: Firefox<29, Android 2.3
6482    // Vendor-prefix box-sizing
6483    "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
6484    "box-sizing:content-box;display:block;margin:0;border:0;" +
6485    "padding:1px;width:1px;zoom:1";
6486   div.appendChild( document.createElement( "div" ) ).style.width = "5px";
6487   shrinkWrapBlocksVal = div.offsetWidth !== 3;
6488  }
6489
6490  body.removeChild( container );
6491
6492  return shrinkWrapBlocksVal;
6493 };
6494
6495})();
6496var rmargin = (/^margin/);
6497
6498var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6499
6500var getStyles, curCSS,
6501 rposition = /^(top|right|bottom|left)$/;
6502
6503if ( window.getComputedStyle ) {
6504 getStyles = function( elem ) {
6505  return elem.ownerDocument.defaultView.getComputedStyle( elem, null );
6506 };
6507
6508 curCSS = function( elem, name, computed ) {
6509  var width, minWidth, maxWidth, ret,
6510   style = elem.style;
6511
6512  computed = computed || getStyles( elem );
6513
6514  // getPropertyValue is only needed for .css('filter') in IE9, see #12537
6515  ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;
6516
6517  if ( computed ) {
6518
6519   if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
6520    ret = jQuery.style( elem, name );
6521   }
6522
6523   // A tribute to the "awesome hack by Dean Edwards"
6524   // Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
6525   // Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
6526   // this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
6527   if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
6528
6529    // Remember the original values
6530    width = style.width;
6531    minWidth = style.minWidth;
6532    maxWidth = style.maxWidth;
6533
6534    // Put in the new values to get a computed value out
6535    style.minWidth = style.maxWidth = style.width = ret;
6536    ret = computed.width;
6537
6538    // Revert the changed values
6539    style.width = width;
6540    style.minWidth = minWidth;
6541    style.maxWidth = maxWidth;
6542   }
6543  }
6544
6545  // Support: IE
6546  // IE returns zIndex value as an integer.
6547  return ret === undefined ?
6548   ret :
6549   ret + "";
6550 };
6551} else if ( document.documentElement.currentStyle ) {
6552 getStyles = function( elem ) {
6553  return elem.currentStyle;
6554 };
6555
6556 curCSS = function( elem, name, computed ) {
6557  var left, rs, rsLeft, ret,
6558   style = elem.style;
6559
6560  computed = computed || getStyles( elem );
6561  ret = computed ? computed[ name ] : undefined;
6562
6563  // Avoid setting ret to empty string here
6564  // so we don't default to auto
6565  if ( ret == null && style && style[ name ] ) {
6566   ret = style[ name ];
6567  }
6568
6569  // From the awesome hack by Dean Edwards
6570  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6571
6572  // If we're not dealing with a regular pixel number
6573  // but a number that has a weird ending, we need to convert it to pixels
6574  // but not position css attributes, as those are proportional to the parent element instead
6575  // and we can't measure the parent instead because it might trigger a "stacking dolls" problem
6576  if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
6577
6578   // Remember the original values
6579   left = style.left;
6580   rs = elem.runtimeStyle;
6581   rsLeft = rs && rs.left;
6582
6583   // Put in the new values to get a computed value out
6584   if ( rsLeft ) {
6585    rs.left = elem.currentStyle.left;
6586   }
6587   style.left = name === "fontSize" ? "1em" : ret;
6588   ret = style.pixelLeft + "px";
6589
6590   // Revert the changed values
6591   style.left = left;
6592   if ( rsLeft ) {
6593    rs.left = rsLeft;
6594   }
6595  }
6596
6597  // Support: IE
6598  // IE returns zIndex value as an integer.
6599  return ret === undefined ?
6600   ret :
6601   ret + "" || "auto";
6602 };
6603}
6604
6605function addGetHookIf( conditionFn, hookFn ) {
6606 // Define the hook, we'll check on the first run if it's really needed.
6607 return {
6608  get: function() {
6609   var condition = conditionFn();
6610
6611   if ( condition == null ) {
6612    // The test was not ready at this point; screw the hook this time
6613    // but check again when needed next time.
6614    return;
6615   }
6616
6617   if ( condition ) {
6618    // Hook not needed (or it's not possible to use it due to missing dependency),
6619    // remove it.
6620    // Since there are no other hooks for marginRight, remove the whole object.
6621    delete this.get;
6622    return;
6623   }
6624
6625   // Hook needed; redefine it so that the support test is not executed again.
6626
6627   return (this.get = hookFn).apply( this, arguments );
6628  }
6629 };
6630}
6631
6632(function() {
6633 // Minified: var b,c,d,e,f,g, h,i
6634 var div, style, a, pixelPositionVal, boxSizingReliableVal,
6635  reliableHiddenOffsetsVal, reliableMarginRightVal;
6636
6637 // Setup
6638 div = document.createElement( "div" );
6639 div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
6640 a = div.getElementsByTagName( "a" )[ 0 ];
6641 style = a && a.style;
6642
6643 // Finish early in limited (non-browser) environments
6644 if ( !style ) {
6645  return;
6646 }
6647
6648 style.cssText = "float:left;opacity:.5";
6649
6650 // Support: IE<9
6651 // Make sure that element opacity exists (as opposed to filter)
6652 support.opacity = style.opacity === "0.5";
6653
6654 // Verify style float existence
6655 // (IE uses styleFloat instead of cssFloat)
6656 support.cssFloat = !!style.cssFloat;
6657
6658 div.style.backgroundClip = "content-box";
6659 div.cloneNode( true ).style.backgroundClip = "";
6660 support.clearCloneStyle = div.style.backgroundClip === "content-box";
6661
6662 // Support: Firefox<29, Android 2.3
6663 // Vendor-prefix box-sizing
6664 support.boxSizing = style.boxSizing === "" || style.MozBoxSizing === "" ||
6665  style.WebkitBoxSizing === "";
6666
6667 jQuery.extend(support, {
6668  reliableHiddenOffsets: function() {
6669   if ( reliableHiddenOffsetsVal == null ) {
6670    computeStyleTests();
6671   }
6672   return reliableHiddenOffsetsVal;
6673  },
6674
6675  boxSizingReliable: function() {
6676   if ( boxSizingReliableVal == null ) {
6677    computeStyleTests();
6678   }
6679   return boxSizingReliableVal;
6680  },
6681
6682  pixelPosition: function() {
6683   if ( pixelPositionVal == null ) {
6684    computeStyleTests();
6685   }
6686   return pixelPositionVal;
6687  },
6688
6689  // Support: Android 2.3
6690  reliableMarginRight: function() {
6691   if ( reliableMarginRightVal == null ) {
6692    computeStyleTests();
6693   }
6694   return reliableMarginRightVal;
6695  }
6696 });
6697
6698 function computeStyleTests() {
6699  // Minified: var b,c,d,j
6700  var div, body, container, contents;
6701
6702  body = document.getElementsByTagName( "body" )[ 0 ];
6703  if ( !body || !body.style ) {
6704   // Test fired too early or in an unsupported environment, exit.
6705   return;
6706  }
6707
6708  // Setup
6709  div = document.createElement( "div" );
6710  container = document.createElement( "div" );
6711  container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
6712  body.appendChild( container ).appendChild( div );
6713
6714  div.style.cssText =
6715   // Support: Firefox<29, Android 2.3
6716   // Vendor-prefix box-sizing
6717   "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;" +
6718   "box-sizing:border-box;display:block;margin-top:1%;top:1%;" +
6719   "border:1px;padding:1px;width:4px;position:absolute";
6720
6721  // Support: IE<9
6722  // Assume reasonable values in the absence of getComputedStyle
6723  pixelPositionVal = boxSizingReliableVal = false;
6724  reliableMarginRightVal = true;
6725
6726  // Check for getComputedStyle so that this code is not run in IE<9.
6727  if ( window.getComputedStyle ) {
6728   pixelPositionVal = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
6729   boxSizingReliableVal =
6730    ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
6731
6732   // Support: Android 2.3
6733   // Div with explicit width and no margin-right incorrectly
6734   // gets computed margin-right based on width of container (#3333)
6735   // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6736   contents = div.appendChild( document.createElement( "div" ) );
6737
6738   // Reset CSS: box-sizing; display; margin; border; padding
6739   contents.style.cssText = div.style.cssText =
6740    // Support: Firefox<29, Android 2.3
6741    // Vendor-prefix box-sizing
6742    "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
6743    "box-sizing:content-box;display:block;margin:0;border:0;padding:0";
6744   contents.style.marginRight = contents.style.width = "0";
6745   div.style.width = "1px";
6746
6747   reliableMarginRightVal =
6748    !parseFloat( ( window.getComputedStyle( contents, null ) || {} ).marginRight );
6749  }
6750
6751  // Support: IE8
6752  // Check if table cells still have offsetWidth/Height when they are set
6753  // to display:none and there are still other visible table cells in a
6754  // table row; if so, offsetWidth/Height are not reliable for use when
6755  // determining if an element has been hidden directly using
6756  // display:none (it is still safe to use offsets if a parent element is
6757  // hidden; don safety goggles and see bug #4512 for more information).
6758  div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
6759  contents = div.getElementsByTagName( "td" );
6760  contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none";
6761  reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
6762  if ( reliableHiddenOffsetsVal ) {
6763   contents[ 0 ].style.display = "";
6764   contents[ 1 ].style.display = "none";
6765   reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
6766  }
6767
6768  body.removeChild( container );
6769 }
6770
6771})();
6772
6773// A method for quickly swapping in/out CSS properties to get correct calculations.
6774jQuery.swap = function( elem, options, callback, args ) {
6775 var ret, name,
6776  old = {};
6777
6778 // Remember the old values, and insert the new ones
6779 for ( name in options ) {
6780  old[ name ] = elem.style[ name ];
6781  elem.style[ name ] = options[ name ];
6782 }
6783
6784 ret = callback.apply( elem, args || [] );
6785
6786 // Revert the old values
6787 for ( name in options ) {
6788  elem.style[ name ] = old[ name ];
6789 }
6790
6791 return ret;
6792};
6793
6794var
6795  ralpha = /alpha\([^)]*\)/i,
6796 ropacity = /opacity\s*=\s*([^)]*)/,
6797
6798 // swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
6799 // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6800 rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6801 rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
6802 rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),
6803
6804 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6805 cssNormalTransform = {
6806  letterSpacing: "0",
6807  fontWeight: "400"
6808 },
6809
6810 cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
6811
6812// return a css property mapped to a potentially vendor prefixed property
6813function vendorPropName( style, name ) {
6814
6815 // shortcut for names that are not vendor prefixed
6816 if ( name in style ) {
6817  return name;
6818 }
6819
6820 // check for vendor prefixed names
6821 var capName = name.charAt(0).toUpperCase() + name.slice(1),
6822  origName = name,
6823  i = cssPrefixes.length;
6824
6825 while ( i-- ) {
6826  name = cssPrefixes[ i ] + capName;
6827  if ( name in style ) {
6828   return name;
6829  }
6830 }
6831
6832 return origName;
6833}
6834
6835function showHide( elements, show ) {
6836 var display, elem, hidden,
6837  values = [],
6838  index = 0,
6839  length = elements.length;
6840
6841 for ( ; index < length; index++ ) {
6842  elem = elements[ index ];
6843  if ( !elem.style ) {
6844   continue;
6845  }
6846
6847  values[ index ] = jQuery._data( elem, "olddisplay" );
6848  display = elem.style.display;
6849  if ( show ) {
6850   // Reset the inline display of this element to learn if it is
6851   // being hidden by cascaded rules or not
6852   if ( !values[ index ] && display === "none" ) {
6853    elem.style.display = "";
6854   }
6855
6856   // Set elements which have been overridden with display: none
6857   // in a stylesheet to whatever the default browser style is
6858   // for such an element
6859   if ( elem.style.display === "" && isHidden( elem ) ) {
6860    values[ index ] = jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
6861   }
6862  } else {
6863   hidden = isHidden( elem );
6864
6865   if ( display && display !== "none" || !hidden ) {
6866    jQuery._data( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
6867   }
6868  }
6869 }
6870
6871 // Set the display of most of the elements in a second loop
6872 // to avoid the constant reflow
6873 for ( index = 0; index < length; index++ ) {
6874  elem = elements[ index ];
6875  if ( !elem.style ) {
6876   continue;
6877  }
6878  if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
6879   elem.style.display = show ? values[ index ] || "" : "none";
6880  }
6881 }
6882
6883 return elements;
6884}
6885
6886function setPositiveNumber( elem, value, subtract ) {
6887 var matches = rnumsplit.exec( value );
6888 return matches ?
6889  // Guard against undefined "subtract", e.g., when used as in cssHooks
6890  Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
6891  value;
6892}
6893
6894function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
6895 var i = extra === ( isBorderBox ? "border" : "content" ) ?
6896  // If we already have the right measurement, avoid augmentation
6897  4 :
6898  // Otherwise initialize for horizontal or vertical properties
6899  name === "width" ? 1 : 0,
6900
6901  val = 0;
6902
6903 for ( ; i < 4; i += 2 ) {
6904  // both box models exclude margin, so add it if we want it
6905  if ( extra === "margin" ) {
6906   val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
6907  }
6908
6909  if ( isBorderBox ) {
6910   // border-box includes padding, so remove it if we want content
6911   if ( extra === "content" ) {
6912    val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6913   }
6914
6915   // at this point, extra isn't border nor margin, so remove border
6916   if ( extra !== "margin" ) {
6917    val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6918   }
6919  } else {
6920   // at this point, extra isn't content, so add padding
6921   val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6922
6923   // at this point, extra isn't content nor padding, so add border
6924   if ( extra !== "padding" ) {
6925    val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6926   }
6927  }
6928 }
6929
6930 return val;
6931}
6932
6933function getWidthOrHeight( elem, name, extra ) {
6934
6935 // Start with offset property, which is equivalent to the border-box value
6936 var valueIsBorderBox = true,
6937  val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6938  styles = getStyles( elem ),
6939  isBorderBox = support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6940
6941 // some non-html elements return undefined for offsetWidth, so check for null/undefined
6942 // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
6943 // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
6944 if ( val <= 0 || val == null ) {
6945  // Fall back to computed then uncomputed css if necessary
6946  val = curCSS( elem, name, styles );
6947  if ( val < 0 || val == null ) {
6948   val = elem.style[ name ];
6949  }
6950
6951  // Computed unit is not pixels. Stop here and return.
6952  if ( rnumnonpx.test(val) ) {
6953   return val;
6954  }
6955
6956  // we need the check for style in case a browser which returns unreliable values
6957  // for getComputedStyle silently falls back to the reliable elem.style
6958  valueIsBorderBox = isBorderBox && ( support.boxSizingReliable() || val === elem.style[ name ] );
6959
6960  // Normalize "", auto, and prepare for extra
6961  val = parseFloat( val ) || 0;
6962 }
6963
6964 // use the active box-sizing model to add/subtract irrelevant styles
6965 return ( val +
6966  augmentWidthOrHeight(
6967   elem,
6968   name,
6969   extra || ( isBorderBox ? "border" : "content" ),
6970   valueIsBorderBox,
6971   styles
6972  )
6973 ) + "px";
6974}
6975
6976jQuery.extend({
6977 // Add in style property hooks for overriding the default
6978 // behavior of getting and setting a style property
6979 cssHooks: {
6980  opacity: {
6981   get: function( elem, computed ) {
6982    if ( computed ) {
6983     // We should always get a number back from opacity
6984     var ret = curCSS( elem, "opacity" );
6985     return ret === "" ? "1" : ret;
6986    }
6987   }
6988  }
6989 },
6990
6991 // Don't automatically add "px" to these possibly-unitless properties
6992 cssNumber: {
6993  "columnCount": true,
6994  "fillOpacity": true,
6995  "flexGrow": true,
6996  "flexShrink": true,
6997  "fontWeight": true,
6998  "lineHeight": true,
6999  "opacity": true,
7000  "order": true,
7001  "orphans": true,
7002  "widows": true,
7003  "zIndex": true,
7004  "zoom": true
7005 },
7006
7007 // Add in properties whose names you wish to fix before
7008 // setting or getting the value
7009 cssProps: {
7010  // normalize float css property
7011  "float": support.cssFloat ? "cssFloat" : "styleFloat"
7012 },
7013
7014 // Get and set the style property on a DOM Node
7015 style: function( elem, name, value, extra ) {
7016  // Don't set styles on text and comment nodes
7017  if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
7018   return;
7019  }
7020
7021  // Make sure that we're working with the right name
7022  var ret, type, hooks,
7023   origName = jQuery.camelCase( name ),
7024   style = elem.style;
7025
7026  name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
7027
7028  // gets hook for the prefixed version
7029  // followed by the unprefixed version
7030  hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
7031
7032  // Check if we're setting a value
7033  if ( value !== undefined ) {
7034   type = typeof value;
7035
7036   // convert relative number strings (+= or -=) to relative numbers. #7345
7037   if ( type === "string" && (ret = rrelNum.exec( value )) ) {
7038    value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
7039    // Fixes bug #9237
7040    type = "number";
7041   }
7042
7043   // Make sure that null and NaN values aren't set. See: #7116
7044   if ( value == null || value !== value ) {
7045    return;
7046   }
7047
7048   // If a number was passed in, add 'px' to the (except for certain CSS properties)
7049   if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
7050    value += "px";
7051   }
7052
7053   // Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
7054   // but it would mean to define eight (for every problematic property) identical functions
7055   if ( !support.clearCloneStyle && value === "" && name.indexOf("background") === 0 ) {
7056    style[ name ] = "inherit";
7057   }
7058
7059   // If a hook was provided, use that value, otherwise just set the specified value
7060   if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
7061
7062    // Support: IE
7063    // Swallow errors from 'invalid' CSS values (#5509)
7064    try {
7065     style[ name ] = value;
7066    } catch(e) {}
7067   }
7068
7069  } else {
7070   // If a hook was provided get the non-computed value from there
7071   if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
7072    return ret;
7073   }
7074
7075   // Otherwise just get the value from the style object
7076   return style[ name ];
7077  }
7078 },
7079
7080 css: function( elem, name, extra, styles ) {
7081  var num, val, hooks,
7082   origName = jQuery.camelCase( name );
7083
7084  // Make sure that we're working with the right name
7085  name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
7086
7087  // gets hook for the prefixed version
7088  // followed by the unprefixed version
7089  hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
7090
7091  // If a hook was provided get the computed value from there
7092  if ( hooks && "get" in hooks ) {
7093   val = hooks.get( elem, true, extra );
7094  }
7095
7096  // Otherwise, if a way to get the computed value exists, use that
7097  if ( val === undefined ) {
7098   val = curCSS( elem, name, styles );
7099  }
7100
7101  //convert "normal" to computed value
7102  if ( val === "normal" && name in cssNormalTransform ) {
7103   val = cssNormalTransform[ name ];
7104  }
7105
7106  // Return, converting to number if forced or a qualifier was provided and val looks numeric
7107  if ( extra === "" || extra ) {
7108   num = parseFloat( val );
7109   return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
7110  }
7111  return val;
7112 }
7113});
7114
7115jQuery.each([ "height", "width" ], function( i, name ) {
7116 jQuery.cssHooks[ name ] = {
7117  get: function( elem, computed, extra ) {
7118   if ( computed ) {
7119    // certain elements can have dimension info if we invisibly show them
7120    // however, it must have a current display style that would benefit from this
7121    return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ?
7122     jQuery.swap( elem, cssShow, function() {
7123      return getWidthOrHeight( elem, name, extra );
7124     }) :
7125     getWidthOrHeight( elem, name, extra );
7126   }
7127  },
7128
7129  set: function( elem, value, extra ) {
7130   var styles = extra && getStyles( elem );
7131   return setPositiveNumber( elem, value, extra ?
7132    augmentWidthOrHeight(
7133     elem,
7134     name,
7135     extra,
7136     support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
7137     styles
7138    ) : 0
7139   );
7140  }
7141 };
7142});
7143
7144if ( !support.opacity ) {
7145 jQuery.cssHooks.opacity = {
7146  get: function( elem, computed ) {
7147   // IE uses filters for opacity
7148   return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
7149    ( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
7150    computed ? "1" : "";
7151  },
7152
7153  set: function( elem, value ) {
7154   var style = elem.style,
7155    currentStyle = elem.currentStyle,
7156    opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
7157    filter = currentStyle && currentStyle.filter || style.filter || "";
7158
7159   // IE has trouble with opacity if it does not have layout
7160   // Force it by setting the zoom level
7161   style.zoom = 1;
7162
7163   // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
7164   // if value === "", then remove inline opacity #12685
7165   if ( ( value >= 1 || value === "" ) &&
7166     jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
7167     style.removeAttribute ) {
7168
7169    // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
7170    // if "filter:" is present at all, clearType is disabled, we want to avoid this
7171    // style.removeAttribute is IE Only, but so apparently is this code path...
7172    style.removeAttribute( "filter" );
7173
7174    // if there is no filter style applied in a css rule or unset inline opacity, we are done
7175    if ( value === "" || currentStyle && !currentStyle.filter ) {
7176     return;
7177    }
7178   }
7179
7180   // otherwise, set new filter values
7181   style.filter = ralpha.test( filter ) ?
7182    filter.replace( ralpha, opacity ) :
7183    filter + " " + opacity;
7184  }
7185 };
7186}
7187
7188jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
7189 function( elem, computed ) {
7190  if ( computed ) {
7191   // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
7192   // Work around by temporarily setting element display to inline-block
7193   return jQuery.swap( elem, { "display": "inline-block" },
7194    curCSS, [ elem, "marginRight" ] );
7195  }
7196 }
7197);
7198
7199// These hooks are used by animate to expand properties
7200jQuery.each({
7201 margin: "",
7202 padding: "",
7203 border: "Width"
7204}, function( prefix, suffix ) {
7205 jQuery.cssHooks[ prefix + suffix ] = {
7206  expand: function( value ) {
7207   var i = 0,
7208    expanded = {},
7209
7210    // assumes a single number if not a string
7211    parts = typeof value === "string" ? value.split(" ") : [ value ];
7212
7213   for ( ; i < 4; i++ ) {
7214    expanded[ prefix + cssExpand[ i ] + suffix ] =
7215     parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
7216   }
7217
7218   return expanded;
7219  }
7220 };
7221
7222 if ( !rmargin.test( prefix ) ) {
7223  jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
7224 }
7225});
7226
7227jQuery.fn.extend({
7228 css: function( name, value ) {
7229  return access( this, function( elem, name, value ) {
7230   var styles, len,
7231    map = {},
7232    i = 0;
7233
7234   if ( jQuery.isArray( name ) ) {
7235    styles = getStyles( elem );
7236    len = name.length;
7237
7238    for ( ; i < len; i++ ) {
7239     map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
7240    }
7241
7242    return map;
7243   }
7244
7245   return value !== undefined ?
7246    jQuery.style( elem, name, value ) :
7247    jQuery.css( elem, name );
7248  }, name, value, arguments.length > 1 );
7249 },
7250 show: function() {
7251  return showHide( this, true );
7252 },
7253 hide: function() {
7254  return showHide( this );
7255 },
7256 toggle: function( state ) {
7257  if ( typeof state === "boolean" ) {
7258   return state ? this.show() : this.hide();
7259  }
7260
7261  return this.each(function() {
7262   if ( isHidden( this ) ) {
7263    jQuery( this ).show();
7264   } else {
7265    jQuery( this ).hide();
7266   }
7267  });
7268 }
7269});
7270
7271function Tween( elem, options, prop, end, easing ) {
7272 return new Tween.prototype.init( elem, options, prop, end, easing );
7273}
7274jQuery.Tween = Tween;
7275
7276Tween.prototype = {
7277 constructor: Tween,
7278 init: function( elem, options, prop, end, easing, unit ) {
7279  this.elem = elem;
7280  this.prop = prop;
7281  this.easing = easing || "swing";
7282  this.options = options;
7283  this.start = this.now = this.cur();
7284  this.end = end;
7285  this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
7286 },
7287 cur: function() {
7288  var hooks = Tween.propHooks[ this.prop ];
7289
7290  return hooks && hooks.get ?
7291   hooks.get( this ) :
7292   Tween.propHooks._default.get( this );
7293 },
7294 run: function( percent ) {
7295  var eased,
7296   hooks = Tween.propHooks[ this.prop ];
7297
7298  if ( this.options.duration ) {
7299   this.pos = eased = jQuery.easing[ this.easing ](
7300    percent, this.options.duration * percent, 0, 1, this.options.duration
7301   );
7302  } else {
7303   this.pos = eased = percent;
7304  }
7305  this.now = ( this.end - this.start ) * eased + this.start;
7306
7307  if ( this.options.step ) {
7308   this.options.step.call( this.elem, this.now, this );
7309  }
7310
7311  if ( hooks && hooks.set ) {
7312   hooks.set( this );
7313  } else {
7314   Tween.propHooks._default.set( this );
7315  }
7316  return this;
7317 }
7318};
7319
7320Tween.prototype.init.prototype = Tween.prototype;
7321
7322Tween.propHooks = {
7323 _default: {
7324  get: function( tween ) {
7325   var result;
7326
7327   if ( tween.elem[ tween.prop ] != null &&
7328    (!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
7329    return tween.elem[ tween.prop ];
7330   }
7331
7332   // passing an empty string as a 3rd parameter to .css will automatically
7333   // attempt a parseFloat and fallback to a string if the parse fails
7334   // so, simple values such as "10px" are parsed to Float.
7335   // complex values such as "rotate(1rad)" are returned as is.
7336   result = jQuery.css( tween.elem, tween.prop, "" );
7337   // Empty strings, null, undefined and "auto" are converted to 0.
7338   return !result || result === "auto" ? 0 : result;
7339  },
7340  set: function( tween ) {
7341   // use step hook for back compat - use cssHook if its there - use .style if its
7342   // available and use plain properties where available
7343   if ( jQuery.fx.step[ tween.prop ] ) {
7344    jQuery.fx.step[ tween.prop ]( tween );
7345   } else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
7346    jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
7347   } else {
7348    tween.elem[ tween.prop ] = tween.now;
7349   }
7350  }
7351 }
7352};
7353
7354// Support: IE <=9
7355// Panic based approach to setting things on disconnected nodes
7356
7357Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
7358 set: function( tween ) {
7359  if ( tween.elem.nodeType && tween.elem.parentNode ) {
7360   tween.elem[ tween.prop ] = tween.now;
7361  }
7362 }
7363};
7364
7365jQuery.easing = {
7366 linear: function( p ) {
7367  return p;
7368 },
7369 swing: function( p ) {
7370  return 0.5 - Math.cos( p * Math.PI ) / 2;
7371 }
7372};
7373
7374jQuery.fx = Tween.prototype.init;
7375
7376// Back Compat <1.8 extension point
7377jQuery.fx.step = {};
7378
7379var
7380 fxNow, timerId,
7381 rfxtypes = /^(?:toggle|show|hide)$/,
7382 rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ),
7383 rrun = /queueHooks$/,
7384 animationPrefilters = [ defaultPrefilter ],
7385 tweeners = {
7386  "*": [ function( prop, value ) {
7387   var tween = this.createTween( prop, value ),
7388    target = tween.cur(),
7389    parts = rfxnum.exec( value ),
7390    unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
7391
7392    // Starting value computation is required for potential unit mismatches
7393    start = ( jQuery.cssNumber[ prop ] || unit !== "px" && +target ) &&
7394     rfxnum.exec( jQuery.css( tween.elem, prop ) ),
7395    scale = 1,
7396    maxIterations = 20;
7397
7398   if ( start && start[ 3 ] !== unit ) {
7399    // Trust units reported by jQuery.css
7400    unit = unit || start[ 3 ];
7401
7402    // Make sure we update the tween properties later on
7403    parts = parts || [];
7404
7405    // Iteratively approximate from a nonzero starting point
7406    start = +target || 1;
7407
7408    do {
7409     // If previous iteration zeroed out, double until we get *something*
7410     // Use a string for doubling factor so we don't accidentally see scale as unchanged below
7411     scale = scale || ".5";
7412
7413     // Adjust and apply
7414     start = start / scale;
7415     jQuery.style( tween.elem, prop, start + unit );
7416
7417    // Update scale, tolerating zero or NaN from tween.cur()
7418    // And breaking the loop if scale is unchanged or perfect, or if we've just had enough
7419    } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
7420   }
7421
7422   // Update tween properties
7423   if ( parts ) {
7424    start = tween.start = +start || +target || 0;
7425    tween.unit = unit;
7426    // If a +=/-= token was provided, we're doing a relative animation
7427    tween.end = parts[ 1 ] ?
7428     start + ( parts[ 1 ] + 1 ) * parts[ 2 ] :
7429     +parts[ 2 ];
7430   }
7431
7432   return tween;
7433  } ]
7434 };
7435
7436// Animations created synchronously will run synchronously
7437function createFxNow() {
7438 setTimeout(function() {
7439  fxNow = undefined;
7440 });
7441 return ( fxNow = jQuery.now() );
7442}
7443
7444// Generate parameters to create a standard animation
7445function genFx( type, includeWidth ) {
7446 var which,
7447  attrs = { height: type },
7448  i = 0;
7449
7450 // if we include width, step value is 1 to do all cssExpand values,
7451 // if we don't include width, step value is 2 to skip over Left and Right
7452 includeWidth = includeWidth ? 1 : 0;
7453 for ( ; i < 4 ; i += 2 - includeWidth ) {
7454  which = cssExpand[ i ];
7455  attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
7456 }
7457
7458 if ( includeWidth ) {
7459  attrs.opacity = attrs.width = type;
7460 }
7461
7462 return attrs;
7463}
7464
7465function createTween( value, prop, animation ) {
7466 var tween,
7467  collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
7468  index = 0,
7469  length = collection.length;
7470 for ( ; index < length; index++ ) {
7471  if ( (tween = collection[ index ].call( animation, prop, value )) ) {
7472
7473   // we're done with this property
7474   return tween;
7475  }
7476 }
7477}
7478
7479function defaultPrefilter( elem, props, opts ) {
7480 /* jshint validthis: true */
7481 var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
7482  anim = this,
7483  orig = {},
7484  style = elem.style,
7485  hidden = elem.nodeType && isHidden( elem ),
7486  dataShow = jQuery._data( elem, "fxshow" );
7487
7488 // handle queue: false promises
7489 if ( !opts.queue ) {
7490  hooks = jQuery._queueHooks( elem, "fx" );
7491  if ( hooks.unqueued == null ) {
7492   hooks.unqueued = 0;
7493   oldfire = hooks.empty.fire;
7494   hooks.empty.fire = function() {
7495    if ( !hooks.unqueued ) {
7496     oldfire();
7497    }
7498   };
7499  }
7500  hooks.unqueued++;
7501
7502  anim.always(function() {
7503   // doing this makes sure that the complete handler will be called
7504   // before this completes
7505   anim.always(function() {
7506    hooks.unqueued--;
7507    if ( !jQuery.queue( elem, "fx" ).length ) {
7508     hooks.empty.fire();
7509    }
7510   });
7511  });
7512 }
7513
7514 // height/width overflow pass
7515 if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
7516  // Make sure that nothing sneaks out
7517  // Record all 3 overflow attributes because IE does not
7518  // change the overflow attribute when overflowX and
7519  // overflowY are set to the same value
7520  opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
7521
7522  // Set display property to inline-block for height/width
7523  // animations on inline elements that are having width/height animated
7524  display = jQuery.css( elem, "display" );
7525
7526  // Test default display if display is currently "none"
7527  checkDisplay = display === "none" ?
7528   jQuery._data( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
7529
7530  if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
7531
7532   // inline-level elements accept inline-block;
7533   // block-level elements need to be inline with layout
7534   if ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === "inline" ) {
7535    style.display = "inline-block";
7536   } else {
7537    style.zoom = 1;
7538   }
7539  }
7540 }
7541
7542 if ( opts.overflow ) {
7543  style.overflow = "hidden";
7544  if ( !support.shrinkWrapBlocks() ) {
7545   anim.always(function() {
7546    style.overflow = opts.overflow[ 0 ];
7547    style.overflowX = opts.overflow[ 1 ];
7548    style.overflowY = opts.overflow[ 2 ];
7549   });
7550  }
7551 }
7552
7553 // show/hide pass
7554 for ( prop in props ) {
7555  value = props[ prop ];
7556  if ( rfxtypes.exec( value ) ) {
7557   delete props[ prop ];
7558   toggle = toggle || value === "toggle";
7559   if ( value === ( hidden ? "hide" : "show" ) ) {
7560
7561    // If there is dataShow left over from a stopped hide or show and we are going to proceed with show, we should pretend to be hidden
7562    if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
7563     hidden = true;
7564    } else {
7565     continue;
7566    }
7567   }
7568   orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
7569
7570  // Any non-fx value stops us from restoring the original display value
7571  } else {
7572   display = undefined;
7573  }
7574 }
7575
7576 if ( !jQuery.isEmptyObject( orig ) ) {
7577  if ( dataShow ) {
7578   if ( "hidden" in dataShow ) {
7579    hidden = dataShow.hidden;
7580   }
7581  } else {
7582   dataShow = jQuery._data( elem, "fxshow", {} );
7583  }
7584
7585  // store state if its toggle - enables .stop().toggle() to "reverse"
7586  if ( toggle ) {
7587   dataShow.hidden = !hidden;
7588  }
7589  if ( hidden ) {
7590   jQuery( elem ).show();
7591  } else {
7592   anim.done(function() {
7593    jQuery( elem ).hide();
7594   });
7595  }
7596  anim.done(function() {
7597   var prop;
7598   jQuery._removeData( elem, "fxshow" );
7599   for ( prop in orig ) {
7600    jQuery.style( elem, prop, orig[ prop ] );
7601   }
7602  });
7603  for ( prop in orig ) {
7604   tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
7605
7606   if ( !( prop in dataShow ) ) {
7607    dataShow[ prop ] = tween.start;
7608    if ( hidden ) {
7609     tween.end = tween.start;
7610     tween.start = prop === "width" || prop === "height" ? 1 : 0;
7611    }
7612   }
7613  }
7614
7615 // If this is a noop like .hide().hide(), restore an overwritten display value
7616 } else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) {
7617  style.display = display;
7618 }
7619}
7620
7621function propFilter( props, specialEasing ) {
7622 var index, name, easing, value, hooks;
7623
7624 // camelCase, specialEasing and expand cssHook pass
7625 for ( index in props ) {
7626  name = jQuery.camelCase( index );
7627  easing = specialEasing[ name ];
7628  value = props[ index ];
7629  if ( jQuery.isArray( value ) ) {
7630   easing = value[ 1 ];
7631   value = props[ index ] = value[ 0 ];
7632  }
7633
7634  if ( index !== name ) {
7635   props[ name ] = value;
7636   delete props[ index ];
7637  }
7638
7639  hooks = jQuery.cssHooks[ name ];
7640  if ( hooks && "expand" in hooks ) {
7641   value = hooks.expand( value );
7642   delete props[ name ];
7643
7644   // not quite $.extend, this wont overwrite keys already present.
7645   // also - reusing 'index' from above because we have the correct "name"
7646   for ( index in value ) {
7647    if ( !( index in props ) ) {
7648     props[ index ] = value[ index ];
7649     specialEasing[ index ] = easing;
7650    }
7651   }
7652  } else {
7653   specialEasing[ name ] = easing;
7654  }
7655 }
7656}
7657
7658function Animation( elem, properties, options ) {
7659 var result,
7660  stopped,
7661  index = 0,
7662  length = animationPrefilters.length,
7663  deferred = jQuery.Deferred().always( function() {
7664   // don't match elem in the :animated selector
7665   delete tick.elem;
7666  }),
7667  tick = function() {
7668   if ( stopped ) {
7669    return false;
7670   }
7671   var currentTime = fxNow || createFxNow(),
7672    remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
7673    // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
7674    temp = remaining / animation.duration || 0,
7675    percent = 1 - temp,
7676    index = 0,
7677    length = animation.tweens.length;
7678
7679   for ( ; index < length ; index++ ) {
7680    animation.tweens[ index ].run( percent );
7681   }
7682
7683   deferred.notifyWith( elem, [ animation, percent, remaining ]);
7684
7685   if ( percent < 1 && length ) {
7686    return remaining;
7687   } else {
7688    deferred.resolveWith( elem, [ animation ] );
7689    return false;
7690   }
7691  },
7692  animation = deferred.promise({
7693   elem: elem,
7694   props: jQuery.extend( {}, properties ),
7695   opts: jQuery.extend( true, { specialEasing: {} }, options ),
7696   originalProperties: properties,
7697   originalOptions: options,
7698   startTime: fxNow || createFxNow(),
7699   duration: options.duration,
7700   tweens: [],
7701   createTween: function( prop, end ) {
7702    var tween = jQuery.Tween( elem, animation.opts, prop, end,
7703      animation.opts.specialEasing[ prop ] || animation.opts.easing );
7704    animation.tweens.push( tween );
7705    return tween;
7706   },
7707   stop: function( gotoEnd ) {
7708    var index = 0,
7709     // if we are going to the end, we want to run all the tweens
7710     // otherwise we skip this part
7711     length = gotoEnd ? animation.tweens.length : 0;
7712    if ( stopped ) {
7713     return this;
7714    }
7715    stopped = true;
7716    for ( ; index < length ; index++ ) {
7717     animation.tweens[ index ].run( 1 );
7718    }
7719
7720    // resolve when we played the last frame
7721    // otherwise, reject
7722    if ( gotoEnd ) {
7723     deferred.resolveWith( elem, [ animation, gotoEnd ] );
7724    } else {
7725     deferred.rejectWith( elem, [ animation, gotoEnd ] );
7726    }
7727    return this;
7728   }
7729  }),
7730  props = animation.props;
7731
7732 propFilter( props, animation.opts.specialEasing );
7733
7734 for ( ; index < length ; index++ ) {
7735  result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
7736  if ( result ) {
7737   return result;
7738  }
7739 }
7740
7741 jQuery.map( props, createTween, animation );
7742
7743 if ( jQuery.isFunction( animation.opts.start ) ) {
7744  animation.opts.start.call( elem, animation );
7745 }
7746
7747 jQuery.fx.timer(
7748  jQuery.extend( tick, {
7749   elem: elem,
7750   anim: animation,
7751   queue: animation.opts.queue
7752  })
7753 );
7754
7755 // attach callbacks from options
7756 return animation.progress( animation.opts.progress )
7757  .done( animation.opts.done, animation.opts.complete )
7758  .fail( animation.opts.fail )
7759  .always( animation.opts.always );
7760}
7761
7762jQuery.Animation = jQuery.extend( Animation, {
7763 tweener: function( props, callback ) {
7764  if ( jQuery.isFunction( props ) ) {
7765   callback = props;
7766   props = [ "*" ];
7767  } else {
7768   props = props.split(" ");
7769  }
7770
7771  var prop,
7772   index = 0,
7773   length = props.length;
7774
7775  for ( ; index < length ; index++ ) {
7776   prop = props[ index ];
7777   tweeners[ prop ] = tweeners[ prop ] || [];
7778   tweeners[ prop ].unshift( callback );
7779  }
7780 },
7781
7782 prefilter: function( callback, prepend ) {
7783  if ( prepend ) {
7784   animationPrefilters.unshift( callback );
7785  } else {
7786   animationPrefilters.push( callback );
7787  }
7788 }
7789});
7790
7791jQuery.speed = function( speed, easing, fn ) {
7792 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
7793  complete: fn || !fn && easing ||
7794   jQuery.isFunction( speed ) && speed,
7795  duration: speed,
7796  easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
7797 };
7798
7799 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
7800  opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
7801
7802 // normalize opt.queue - true/undefined/null -> "fx"
7803 if ( opt.queue == null || opt.queue === true ) {
7804  opt.queue = "fx";
7805 }
7806
7807 // Queueing
7808 opt.old = opt.complete;
7809
7810 opt.complete = function() {
7811  if ( jQuery.isFunction( opt.old ) ) {
7812   opt.old.call( this );
7813  }
7814
7815  if ( opt.queue ) {
7816   jQuery.dequeue( this, opt.queue );
7817  }
7818 };
7819
7820 return opt;
7821};
7822
7823jQuery.fn.extend({
7824 fadeTo: function( speed, to, easing, callback ) {
7825
7826  // show any hidden elements after setting opacity to 0
7827  return this.filter( isHidden ).css( "opacity", 0 ).show()
7828
7829   // animate to the value specified
7830   .end().animate({ opacity: to }, speed, easing, callback );
7831 },
7832 animate: function( prop, speed, easing, callback ) {
7833  var empty = jQuery.isEmptyObject( prop ),
7834   optall = jQuery.speed( speed, easing, callback ),
7835   doAnimation = function() {
7836    // Operate on a copy of prop so per-property easing won't be lost
7837    var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7838
7839    // Empty animations, or finishing resolves immediately
7840    if ( empty || jQuery._data( this, "finish" ) ) {
7841     anim.stop( true );
7842    }
7843   };
7844   doAnimation.finish = doAnimation;
7845
7846  return empty || optall.queue === false ?
7847   this.each( doAnimation ) :
7848   this.queue( optall.queue, doAnimation );
7849 },
7850 stop: function( type, clearQueue, gotoEnd ) {
7851  var stopQueue = function( hooks ) {
7852   var stop = hooks.stop;
7853   delete hooks.stop;
7854   stop( gotoEnd );
7855  };
7856
7857  if ( typeof type !== "string" ) {
7858   gotoEnd = clearQueue;
7859   clearQueue = type;
7860   type = undefined;
7861  }
7862  if ( clearQueue && type !== false ) {
7863   this.queue( type || "fx", [] );
7864  }
7865
7866  return this.each(function() {
7867   var dequeue = true,
7868    index = type != null && type + "queueHooks",
7869    timers = jQuery.timers,
7870    data = jQuery._data( this );
7871
7872   if ( index ) {
7873    if ( data[ index ] && data[ index ].stop ) {
7874     stopQueue( data[ index ] );
7875    }
7876   } else {
7877    for ( index in data ) {
7878     if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
7879      stopQueue( data[ index ] );
7880     }
7881    }
7882   }
7883
7884   for ( index = timers.length; index--; ) {
7885    if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
7886     timers[ index ].anim.stop( gotoEnd );
7887     dequeue = false;
7888     timers.splice( index, 1 );
7889    }
7890   }
7891
7892   // start the next in the queue if the last step wasn't forced
7893   // timers currently will call their complete callbacks, which will dequeue
7894   // but only if they were gotoEnd
7895   if ( dequeue || !gotoEnd ) {
7896    jQuery.dequeue( this, type );
7897   }
7898  });
7899 },
7900 finish: function( type ) {
7901  if ( type !== false ) {
7902   type = type || "fx";
7903  }
7904  return this.each(function() {
7905   var index,
7906    data = jQuery._data( this ),
7907    queue = data[ type + "queue" ],
7908    hooks = data[ type + "queueHooks" ],
7909    timers = jQuery.timers,
7910    length = queue ? queue.length : 0;
7911
7912   // enable finishing flag on private data
7913   data.finish = true;
7914
7915   // empty the queue first
7916   jQuery.queue( this, type, [] );
7917
7918   if ( hooks && hooks.stop ) {
7919    hooks.stop.call( this, true );
7920   }
7921
7922   // look for any active animations, and finish them
7923   for ( index = timers.length; index--; ) {
7924    if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
7925     timers[ index ].anim.stop( true );
7926     timers.splice( index, 1 );
7927    }
7928   }
7929
7930   // look for any animations in the old queue and finish them
7931   for ( index = 0; index < length; index++ ) {
7932    if ( queue[ index ] && queue[ index ].finish ) {
7933     queue[ index ].finish.call( this );
7934    }
7935   }
7936
7937   // turn off finishing flag
7938   delete data.finish;
7939  });
7940 }
7941});
7942
7943jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
7944 var cssFn = jQuery.fn[ name ];
7945 jQuery.fn[ name ] = function( speed, easing, callback ) {
7946  return speed == null || typeof speed === "boolean" ?
7947   cssFn.apply( this, arguments ) :
7948   this.animate( genFx( name, true ), speed, easing, callback );
7949 };
7950});
7951
7952// Generate shortcuts for custom animations
7953jQuery.each({
7954 slideDown: genFx("show"),
7955 slideUp: genFx("hide"),
7956 slideToggle: genFx("toggle"),
7957 fadeIn: { opacity: "show" },
7958 fadeOut: { opacity: "hide" },
7959 fadeToggle: { opacity: "toggle" }
7960}, function( name, props ) {
7961 jQuery.fn[ name ] = function( speed, easing, callback ) {
7962  return this.animate( props, speed, easing, callback );
7963 };
7964});
7965
7966jQuery.timers = [];
7967jQuery.fx.tick = function() {
7968 var timer,
7969  timers = jQuery.timers,
7970  i = 0;
7971
7972 fxNow = jQuery.now();
7973
7974 for ( ; i < timers.length; i++ ) {
7975  timer = timers[ i ];
7976  // Checks the timer has not already been removed
7977  if ( !timer() && timers[ i ] === timer ) {
7978   timers.splice( i--, 1 );
7979  }
7980 }
7981
7982 if ( !timers.length ) {
7983  jQuery.fx.stop();
7984 }
7985 fxNow = undefined;
7986};
7987
7988jQuery.fx.timer = function( timer ) {
7989 jQuery.timers.push( timer );
7990 if ( timer() ) {
7991  jQuery.fx.start();
7992 } else {
7993  jQuery.timers.pop();
7994 }
7995};
7996
7997jQuery.fx.interval = 13;
7998
7999jQuery.fx.start = function() {
8000 if ( !timerId ) {
8001  timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
8002 }
8003};
8004
8005jQuery.fx.stop = function() {
8006 clearInterval( timerId );
8007 timerId = null;
8008};
8009
8010jQuery.fx.speeds = {
8011 slow: 600,
8012 fast: 200,
8013 // Default speed
8014 _default: 400
8015};
8016
8017// Based off of the plugin by Clint Helfers, with permission.
8018// http://blindsignals.com/index.php/2009/07/jquery-delay/
8019jQuery.fn.delay = function( time, type ) {
8020 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
8021 type = type || "fx";
8022
8023 return this.queue( type, function( next, hooks ) {
8024  var timeout = setTimeout( next, time );
8025  hooks.stop = function() {
8026   clearTimeout( timeout );
8027  };
8028 });
8029};
8030
8031(function() {
8032 // Minified: var a,b,c,d,e
8033 var input, div, select, a, opt;
8034
8035 // Setup
8036 div = document.createElement( "div" );
8037 div.setAttribute( "className", "t" );
8038 div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
8039 a = div.getElementsByTagName("a")[ 0 ];
8040
8041 // First batch of tests.
8042 select = document.createElement("select");
8043 opt = select.appendChild( document.createElement("option") );
8044 input = div.getElementsByTagName("input")[ 0 ];
8045
8046 a.style.cssText = "top:1px";
8047
8048 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
8049 support.getSetAttribute = div.className !== "t";
8050
8051 // Get the style information from getAttribute
8052 // (IE uses .cssText instead)
8053 support.style = /top/.test( a.getAttribute("style") );
8054
8055 // Make sure that URLs aren't manipulated
8056 // (IE normalizes it by default)
8057 support.hrefNormalized = a.getAttribute("href") === "/a";
8058
8059 // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
8060 support.checkOn = !!input.value;
8061
8062 // Make sure that a selected-by-default option has a working selected property.
8063 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
8064 support.optSelected = opt.selected;
8065
8066 // Tests for enctype support on a form (#6743)
8067 support.enctype = !!document.createElement("form").enctype;
8068
8069 // Make sure that the options inside disabled selects aren't marked as disabled
8070 // (WebKit marks them as disabled)
8071 select.disabled = true;
8072 support.optDisabled = !opt.disabled;
8073
8074 // Support: IE8 only
8075 // Check if we can trust getAttribute("value")
8076 input = document.createElement( "input" );
8077 input.setAttribute( "value", "" );
8078 support.input = input.getAttribute( "value" ) === "";
8079
8080 // Check if an input maintains its value after becoming a radio
8081 input.value = "t";
8082 input.setAttribute( "type", "radio" );
8083 support.radioValue = input.value === "t";
8084})();
8085
8086var rreturn = /\r/g;
8087
8088jQuery.fn.extend({
8089 val: function( value ) {
8090  var hooks, ret, isFunction,
8091   elem = this[0];
8092
8093  if ( !arguments.length ) {
8094   if ( elem ) {
8095    hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
8096
8097    if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
8098     return ret;
8099    }
8100
8101    ret = elem.value;
8102
8103    return typeof ret === "string" ?
8104     // handle most common string cases
8105     ret.replace(rreturn, "") :
8106     // handle cases where value is null/undef or number
8107     ret == null ? "" : ret;
8108   }
8109
8110   return;
8111  }
8112
8113  isFunction = jQuery.isFunction( value );
8114
8115  return this.each(function( i ) {
8116   var val;
8117
8118   if ( this.nodeType !== 1 ) {
8119    return;
8120   }
8121
8122   if ( isFunction ) {
8123    val = value.call( this, i, jQuery( this ).val() );
8124   } else {
8125    val = value;
8126   }
8127
8128   // Treat null/undefined as ""; convert numbers to string
8129   if ( val == null ) {
8130    val = "";
8131   } else if ( typeof val === "number" ) {
8132    val += "";
8133   } else if ( jQuery.isArray( val ) ) {
8134    val = jQuery.map( val, function( value ) {
8135     return value == null ? "" : value + "";
8136    });
8137   }
8138
8139   hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
8140
8141   // If set returns undefined, fall back to normal setting
8142   if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
8143    this.value = val;
8144   }
8145  });
8146 }
8147});
8148
8149jQuery.extend({
8150 valHooks: {
8151  option: {
8152   get: function( elem ) {
8153    var val = jQuery.find.attr( elem, "value" );
8154    return val != null ?
8155     val :
8156     // Support: IE10-11+
8157     // option.text throws exceptions (#14686, #14858)
8158     jQuery.trim( jQuery.text( elem ) );
8159   }
8160  },
8161  select: {
8162   get: function( elem ) {
8163    var value, option,
8164     options = elem.options,
8165     index = elem.selectedIndex,
8166     one = elem.type === "select-one" || index < 0,
8167     values = one ? null : [],
8168     max = one ? index + 1 : options.length,
8169     i = index < 0 ?
8170      max :
8171      one ? index : 0;
8172
8173    // Loop through all the selected options
8174    for ( ; i < max; i++ ) {
8175     option = options[ i ];
8176
8177     // oldIE doesn't update selected after form reset (#2551)
8178     if ( ( option.selected || i === index ) &&
8179       // Don't return options that are disabled or in a disabled optgroup
8180       ( support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
8181       ( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
8182
8183      // Get the specific value for the option
8184      value = jQuery( option ).val();
8185
8186      // We don't need an array for one selects
8187      if ( one ) {
8188       return value;
8189      }
8190
8191      // Multi-Selects return an array
8192      values.push( value );
8193     }
8194    }
8195
8196    return values;
8197   },
8198
8199   set: function( elem, value ) {
8200    var optionSet, option,
8201     options = elem.options,
8202     values = jQuery.makeArray( value ),
8203     i = options.length;
8204
8205    while ( i-- ) {
8206     option = options[ i ];
8207
8208     if ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) >= 0 ) {
8209
8210      // Support: IE6
8211      // When new option element is added to select box we need to
8212      // force reflow of newly added node in order to workaround delay
8213      // of initialization properties
8214      try {
8215       option.selected = optionSet = true;
8216
8217      } catch ( _ ) {
8218
8219       // Will be executed only in IE6
8220       option.scrollHeight;
8221      }
8222
8223     } else {
8224      option.selected = false;
8225     }
8226    }
8227
8228    // Force browsers to behave consistently when non-matching value is set
8229    if ( !optionSet ) {
8230     elem.selectedIndex = -1;
8231    }
8232
8233    return options;
8234   }
8235  }
8236 }
8237});
8238
8239// Radios and checkboxes getter/setter
8240jQuery.each([ "radio", "checkbox" ], function() {
8241 jQuery.valHooks[ this ] = {
8242  set: function( elem, value ) {
8243   if ( jQuery.isArray( value ) ) {
8244    return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
8245   }
8246  }
8247 };
8248 if ( !support.checkOn ) {
8249  jQuery.valHooks[ this ].get = function( elem ) {
8250   // Support: Webkit
8251   // "" is returned instead of "on" if a value isn't specified
8252   return elem.getAttribute("value") === null ? "on" : elem.value;
8253  };
8254 }
8255});
8256
8257var nodeHook, boolHook,
8258 attrHandle = jQuery.expr.attrHandle,
8259 ruseDefault = /^(?:checked|selected)$/i,
8260 getSetAttribute = support.getSetAttribute,
8261 getSetInput = support.input;
8262
8263jQuery.fn.extend({
8264 attr: function( name, value ) {
8265  return access( this, jQuery.attr, name, value, arguments.length > 1 );
8266 },
8267
8268 removeAttr: function( name ) {
8269  return this.each(function() {
8270   jQuery.removeAttr( this, name );
8271  });
8272 }
8273});
8274
8275jQuery.extend({
8276 attr: function( elem, name, value ) {
8277  var hooks, ret,
8278   nType = elem.nodeType;
8279
8280  // don't get/set attributes on text, comment and attribute nodes
8281  if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
8282   return;
8283  }
8284
8285  // Fallback to prop when attributes are not supported
8286  if ( typeof elem.getAttribute === strundefined ) {
8287   return jQuery.prop( elem, name, value );
8288  }
8289
8290  // All attributes are lowercase
8291  // Grab necessary hook if one is defined
8292  if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
8293   name = name.toLowerCase();
8294   hooks = jQuery.attrHooks[ name ] ||
8295    ( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
8296  }
8297
8298  if ( value !== undefined ) {
8299
8300   if ( value === null ) {
8301    jQuery.removeAttr( elem, name );
8302
8303   } else if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
8304    return ret;
8305
8306   } else {
8307    elem.setAttribute( name, value + "" );
8308    return value;
8309   }
8310
8311  } else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
8312   return ret;
8313
8314  } else {
8315   ret = jQuery.find.attr( elem, name );
8316
8317   // Non-existent attributes return null, we normalize to undefined
8318   return ret == null ?
8319    undefined :
8320    ret;
8321  }
8322 },
8323
8324 removeAttr: function( elem, value ) {
8325  var name, propName,
8326   i = 0,
8327   attrNames = value && value.match( rnotwhite );
8328
8329  if ( attrNames && elem.nodeType === 1 ) {
8330   while ( (name = attrNames[i++]) ) {
8331    propName = jQuery.propFix[ name ] || name;
8332
8333    // Boolean attributes get special treatment (#10870)
8334    if ( jQuery.expr.match.bool.test( name ) ) {
8335     // Set corresponding property to false
8336     if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
8337      elem[ propName ] = false;
8338     // Support: IE<9
8339     // Also clear defaultChecked/defaultSelected (if appropriate)
8340     } else {
8341      elem[ jQuery.camelCase( "default-" + name ) ] =
8342       elem[ propName ] = false;
8343     }
8344
8345    // See #9699 for explanation of this approach (setting first, then removal)
8346    } else {
8347     jQuery.attr( elem, name, "" );
8348    }
8349
8350    elem.removeAttribute( getSetAttribute ? name : propName );
8351   }
8352  }
8353 },
8354
8355 attrHooks: {
8356  type: {
8357   set: function( elem, value ) {
8358    if ( !support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
8359     // Setting the type on a radio button after the value resets the value in IE6-9
8360     // Reset value to default in case type is set after value during creation
8361     var val = elem.value;
8362     elem.setAttribute( "type", value );
8363     if ( val ) {
8364      elem.value = val;
8365     }
8366     return value;
8367    }
8368   }
8369  }
8370 }
8371});
8372
8373// Hook for boolean attributes
8374boolHook = {
8375 set: function( elem, value, name ) {
8376  if ( value === false ) {
8377   // Remove boolean attributes when set to false
8378   jQuery.removeAttr( elem, name );
8379  } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
8380   // IE<8 needs the *property* name
8381   elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
8382
8383  // Use defaultChecked and defaultSelected for oldIE
8384  } else {
8385   elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
8386  }
8387
8388  return name;
8389 }
8390};
8391
8392// Retrieve booleans specially
8393jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
8394
8395 var getter = attrHandle[ name ] || jQuery.find.attr;
8396
8397 attrHandle[ name ] = getSetInput && getSetAttribute || !ruseDefault.test( name ) ?
8398  function( elem, name, isXML ) {
8399   var ret, handle;
8400   if ( !isXML ) {
8401    // Avoid an infinite loop by temporarily removing this function from the getter
8402    handle = attrHandle[ name ];
8403    attrHandle[ name ] = ret;
8404    ret = getter( elem, name, isXML ) != null ?
8405     name.toLowerCase() :
8406     null;
8407    attrHandle[ name ] = handle;
8408   }
8409   return ret;
8410  } :
8411  function( elem, name, isXML ) {
8412   if ( !isXML ) {
8413    return elem[ jQuery.camelCase( "default-" + name ) ] ?
8414     name.toLowerCase() :
8415     null;
8416   }
8417  };
8418});
8419
8420// fix oldIE attroperties
8421if ( !getSetInput || !getSetAttribute ) {
8422 jQuery.attrHooks.value = {
8423  set: function( elem, value, name ) {
8424   if ( jQuery.nodeName( elem, "input" ) ) {
8425    // Does not return so that setAttribute is also used
8426    elem.defaultValue = value;
8427   } else {
8428    // Use nodeHook if defined (#1954); otherwise setAttribute is fine
8429    return nodeHook && nodeHook.set( elem, value, name );
8430   }
8431  }
8432 };
8433}
8434
8435// IE6/7 do not support getting/setting some attributes with get/setAttribute
8436if ( !getSetAttribute ) {
8437
8438 // Use this for any attribute in IE6/7
8439 // This fixes almost every IE6/7 issue
8440 nodeHook = {
8441  set: function( elem, value, name ) {
8442   // Set the existing or create a new attribute node
8443   var ret = elem.getAttributeNode( name );
8444   if ( !ret ) {
8445    elem.setAttributeNode(
8446     (ret = elem.ownerDocument.createAttribute( name ))
8447    );
8448   }
8449
8450   ret.value = value += "";
8451
8452   // Break association with cloned elements by also using setAttribute (#9646)
8453   if ( name === "value" || value === elem.getAttribute( name ) ) {
8454    return value;
8455   }
8456  }
8457 };
8458
8459 // Some attributes are constructed with empty-string values when not defined
8460 attrHandle.id = attrHandle.name = attrHandle.coords =
8461  function( elem, name, isXML ) {
8462   var ret;
8463   if ( !isXML ) {
8464    return (ret = elem.getAttributeNode( name )) && ret.value !== "" ?
8465     ret.value :
8466     null;
8467   }
8468  };
8469
8470 // Fixing value retrieval on a button requires this module
8471 jQuery.valHooks.button = {
8472  get: function( elem, name ) {
8473   var ret = elem.getAttributeNode( name );
8474   if ( ret && ret.specified ) {
8475    return ret.value;
8476   }
8477  },
8478  set: nodeHook.set
8479 };
8480
8481 // Set contenteditable to false on removals(#10429)
8482 // Setting to empty string throws an error as an invalid value
8483 jQuery.attrHooks.contenteditable = {
8484  set: function( elem, value, name ) {
8485   nodeHook.set( elem, value === "" ? false : value, name );
8486  }
8487 };
8488
8489 // Set width and height to auto instead of 0 on empty string( Bug #8150 )
8490 // This is for removals
8491 jQuery.each([ "width", "height" ], function( i, name ) {
8492  jQuery.attrHooks[ name ] = {
8493   set: function( elem, value ) {
8494    if ( value === "" ) {
8495     elem.setAttribute( name, "auto" );
8496     return value;
8497    }
8498   }
8499  };
8500 });
8501}
8502
8503if ( !support.style ) {
8504 jQuery.attrHooks.style = {
8505  get: function( elem ) {
8506   // Return undefined in the case of empty string
8507   // Note: IE uppercases css property names, but if we were to .toLowerCase()
8508   // .cssText, that would destroy case senstitivity in URL's, like in "background"
8509   return elem.style.cssText || undefined;
8510  },
8511  set: function( elem, value ) {
8512   return ( elem.style.cssText = value + "" );
8513  }
8514 };
8515}
8516
8517var rfocusable = /^(?:input|select|textarea|button|object)$/i,
8518 rclickable = /^(?:a|area)$/i;
8519
8520jQuery.fn.extend({
8521 prop: function( name, value ) {
8522  return access( this, jQuery.prop, name, value, arguments.length > 1 );
8523 },
8524
8525 removeProp: function( name ) {
8526  name = jQuery.propFix[ name ] || name;
8527  return this.each(function() {
8528   // try/catch handles cases where IE balks (such as removing a property on window)
8529   try {
8530    this[ name ] = undefined;
8531    delete this[ name ];
8532   } catch( e ) {}
8533  });
8534 }
8535});
8536
8537jQuery.extend({
8538 propFix: {
8539  "for": "htmlFor",
8540  "class": "className"
8541 },
8542
8543 prop: function( elem, name, value ) {
8544  var ret, hooks, notxml,
8545   nType = elem.nodeType;
8546
8547  // don't get/set properties on text, comment and attribute nodes
8548  if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
8549   return;
8550  }
8551
8552  notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
8553
8554  if ( notxml ) {
8555   // Fix name and attach hooks
8556   name = jQuery.propFix[ name ] || name;
8557   hooks = jQuery.propHooks[ name ];
8558  }
8559
8560  if ( value !== undefined ) {
8561   return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ?
8562    ret :
8563    ( elem[ name ] = value );
8564
8565  } else {
8566   return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ?
8567    ret :
8568    elem[ name ];
8569  }
8570 },
8571
8572 propHooks: {
8573  tabIndex: {
8574   get: function( elem ) {
8575    // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
8576    // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
8577    // Use proper attribute retrieval(#12072)
8578    var tabindex = jQuery.find.attr( elem, "tabindex" );
8579
8580    return tabindex ?
8581     parseInt( tabindex, 10 ) :
8582     rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
8583      0 :
8584      -1;
8585   }
8586  }
8587 }
8588});
8589
8590// Some attributes require a special call on IE
8591// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
8592if ( !support.hrefNormalized ) {
8593 // href/src property should get the full normalized URL (#10299/#12915)
8594 jQuery.each([ "href", "src" ], function( i, name ) {
8595  jQuery.propHooks[ name ] = {
8596   get: function( elem ) {
8597    return elem.getAttribute( name, 4 );
8598   }
8599  };
8600 });
8601}
8602
8603// Support: Safari, IE9+
8604// mis-reports the default selected property of an option
8605// Accessing the parent's selectedIndex property fixes it
8606if ( !support.optSelected ) {
8607 jQuery.propHooks.selected = {
8608  get: function( elem ) {
8609   var parent = elem.parentNode;
8610
8611   if ( parent ) {
8612    parent.selectedIndex;
8613
8614    // Make sure that it also works with optgroups, see #5701
8615    if ( parent.parentNode ) {
8616     parent.parentNode.selectedIndex;
8617    }
8618   }
8619   return null;
8620  }
8621 };
8622}
8623
8624jQuery.each([
8625 "tabIndex",
8626 "readOnly",
8627 "maxLength",
8628 "cellSpacing",
8629 "cellPadding",
8630 "rowSpan",
8631 "colSpan",
8632 "useMap",
8633 "frameBorder",
8634 "contentEditable"
8635], function() {
8636 jQuery.propFix[ this.toLowerCase() ] = this;
8637});
8638
8639// IE6/7 call enctype encoding
8640if ( !support.enctype ) {
8641 jQuery.propFix.enctype = "encoding";
8642}
8643
8644var rclass = /[\t\r\n\f]/g;
8645
8646jQuery.fn.extend({
8647 addClass: function( value ) {
8648  var classes, elem, cur, clazz, j, finalValue,
8649   i = 0,
8650   len = this.length,
8651   proceed = typeof value === "string" && value;
8652
8653  if ( jQuery.isFunction( value ) ) {
8654   return this.each(function( j ) {
8655    jQuery( this ).addClass( value.call( this, j, this.className ) );
8656   });
8657  }
8658
8659  if ( proceed ) {
8660   // The disjunction here is for better compressibility (see removeClass)
8661   classes = ( value || "" ).match( rnotwhite ) || [];
8662
8663   for ( ; i < len; i++ ) {
8664    elem = this[ i ];
8665    cur = elem.nodeType === 1 && ( elem.className ?
8666     ( " " + elem.className + " " ).replace( rclass, " " ) :
8667     " "
8668    );
8669
8670    if ( cur ) {
8671     j = 0;
8672     while ( (clazz = classes[j++]) ) {
8673      if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
8674       cur += clazz + " ";
8675      }
8676     }
8677
8678     // only assign if different to avoid unneeded rendering.
8679     finalValue = jQuery.trim( cur );
8680     if ( elem.className !== finalValue ) {
8681      elem.className = finalValue;
8682     }
8683    }
8684   }
8685  }
8686
8687  return this;
8688 },
8689
8690 removeClass: function( value ) {
8691  var classes, elem, cur, clazz, j, finalValue,
8692   i = 0,
8693   len = this.length,
8694   proceed = arguments.length === 0 || typeof value === "string" && value;
8695
8696  if ( jQuery.isFunction( value ) ) {
8697   return this.each(function( j ) {
8698    jQuery( this ).removeClass( value.call( this, j, this.className ) );
8699   });
8700  }
8701  if ( proceed ) {
8702   classes = ( value || "" ).match( rnotwhite ) || [];
8703
8704   for ( ; i < len; i++ ) {
8705    elem = this[ i ];
8706    // This expression is here for better compressibility (see addClass)
8707    cur = elem.nodeType === 1 && ( elem.className ?
8708     ( " " + elem.className + " " ).replace( rclass, " " ) :
8709     ""
8710    );
8711
8712    if ( cur ) {
8713     j = 0;
8714     while ( (clazz = classes[j++]) ) {
8715      // Remove *all* instances
8716      while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
8717       cur = cur.replace( " " + clazz + " ", " " );
8718      }
8719     }
8720
8721     // only assign if different to avoid unneeded rendering.
8722     finalValue = value ? jQuery.trim( cur ) : "";
8723     if ( elem.className !== finalValue ) {
8724      elem.className = finalValue;
8725     }
8726    }
8727   }
8728  }
8729
8730  return this;
8731 },
8732
8733 toggleClass: function( value, stateVal ) {
8734  var type = typeof value;
8735
8736  if ( typeof stateVal === "boolean" && type === "string" ) {
8737   return stateVal ? this.addClass( value ) : this.removeClass( value );
8738  }
8739
8740  if ( jQuery.isFunction( value ) ) {
8741   return this.each(function( i ) {
8742    jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
8743   });
8744  }
8745
8746  return this.each(function() {
8747   if ( type === "string" ) {
8748    // toggle individual class names
8749    var className,
8750     i = 0,
8751     self = jQuery( this ),
8752     classNames = value.match( rnotwhite ) || [];
8753
8754    while ( (className = classNames[ i++ ]) ) {
8755     // check each className given, space separated list
8756     if ( self.hasClass( className ) ) {
8757      self.removeClass( className );
8758     } else {
8759      self.addClass( className );
8760     }
8761    }
8762
8763   // Toggle whole class name
8764   } else if ( type === strundefined || type === "boolean" ) {
8765    if ( this.className ) {
8766     // store className if set
8767     jQuery._data( this, "__className__", this.className );
8768    }
8769
8770    // If the element has a class name or if we're passed "false",
8771    // then remove the whole classname (if there was one, the above saved it).
8772    // Otherwise bring back whatever was previously saved (if anything),
8773    // falling back to the empty string if nothing was stored.
8774    this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
8775   }
8776  });
8777 },
8778
8779 hasClass: function( selector ) {
8780  var className = " " + selector + " ",
8781   i = 0,
8782   l = this.length;
8783  for ( ; i < l; i++ ) {
8784   if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
8785    return true;
8786   }
8787  }
8788
8789  return false;
8790 }
8791});
8792
8793// Return jQuery for attributes-only inclusion
8794
8795jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
8796 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
8797 "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
8798
8799 // Handle event binding
8800 jQuery.fn[ name ] = function( data, fn ) {
8801  return arguments.length > 0 ?
8802   this.on( name, null, data, fn ) :
8803   this.trigger( name );
8804 };
8805});
8806
8807jQuery.fn.extend({
8808 hover: function( fnOver, fnOut ) {
8809  return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
8810 },
8811
8812 bind: function( types, data, fn ) {
8813  return this.on( types, null, data, fn );
8814 },
8815 unbind: function( types, fn ) {
8816  return this.off( types, null, fn );
8817 },
8818
8819 delegate: function( selector, types, data, fn ) {
8820  return this.on( types, selector, data, fn );
8821 },
8822 undelegate: function( selector, types, fn ) {
8823  // ( namespace ) or ( selector, types [, fn] )
8824  return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
8825 }
8826});
8827
8828var nonce = jQuery.now();
8829
8830var rquery = (/\?/);
8831
8832var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;
8833
8834jQuery.parseJSON = function( data ) {
8835 // Attempt to parse using the native JSON parser first
8836 if ( window.JSON && window.JSON.parse ) {
8837  // Support: Android 2.3
8838  // Workaround failure to string-cast null input
8839  return window.JSON.parse( data + "" );
8840 }
8841
8842 var requireNonComma,
8843  depth = null,
8844  str = jQuery.trim( data + "" );
8845
8846 // Guard against invalid (and possibly dangerous) input by ensuring that nothing remains
8847 // after removing valid tokens
8848 return str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) {
8849
8850  // Force termination if we see a misplaced comma
8851  if ( requireNonComma && comma ) {
8852   depth = 0;
8853  }
8854
8855  // Perform no more replacements after returning to outermost depth
8856  if ( depth === 0 ) {
8857   return token;
8858  }
8859
8860  // Commas must not follow "[", "{", or ","
8861  requireNonComma = open || comma;
8862
8863  // Determine new depth
8864  // array/object open ("[" or "{"): depth += true - false (increment)
8865  // array/object close ("]" or "}"): depth += false - true (decrement)
8866  // other cases ("," or primitive): depth += true - true (numeric cast)
8867  depth += !close - !open;
8868
8869  // Remove this token
8870  return "";
8871 }) ) ?
8872  ( Function( "return " + str ) )() :
8873  jQuery.error( "Invalid JSON: " + data );
8874};
8875
8876// Cross-browser xml parsing
8877jQuery.parseXML = function( data ) {
8878 var xml, tmp;
8879 if ( !data || typeof data !== "string" ) {
8880  return null;
8881 }
8882 try {
8883  if ( window.DOMParser ) { // Standard
8884   tmp = new DOMParser();
8885   xml = tmp.parseFromString( data, "text/xml" );
8886  } else { // IE
8887   xml = new ActiveXObject( "Microsoft.XMLDOM" );
8888   xml.async = "false";
8889   xml.loadXML( data );
8890  }
8891 } catch( e ) {
8892  xml = undefined;
8893 }
8894 if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
8895  jQuery.error( "Invalid XML: " + data );
8896 }
8897 return xml;
8898};
8899
8900var
8901 // Document location
8902 ajaxLocParts,
8903 ajaxLocation,
8904
8905 rhash = /#.*$/,
8906 rts = /([?&])_=[^&]*/,
8907 rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
8908 // #7653, #8125, #8152: local protocol detection
8909 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
8910 rnoContent = /^(?:GET|HEAD)$/,
8911 rprotocol = /^\/\//,
8912 rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
8913
8914 /* Prefilters
8915  * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
8916  * 2) These are called:
8917  *    - BEFORE asking for a transport
8918  *    - AFTER param serialization (s.data is a string if s.processData is true)
8919  * 3) key is the dataType
8920  * 4) the catchall symbol "*" can be used
8921  * 5) execution will start with transport dataType and THEN continue down to "*" if needed
8922  */
8923 prefilters = {},
8924
8925 /* Transports bindings
8926  * 1) key is the dataType
8927  * 2) the catchall symbol "*" can be used
8928  * 3) selection will start with transport dataType and THEN go to "*" if needed
8929  */
8930 transports = {},
8931
8932 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
8933 allTypes = "*/".concat("*");
8934
8935// #8138, IE may throw an exception when accessing
8936// a field from window.location if document.domain has been set
8937try {
8938 ajaxLocation = location.href;
8939} catch( e ) {
8940 // Use the href attribute of an A element
8941 // since IE will modify it given document.location
8942 ajaxLocation = document.createElement( "a" );
8943 ajaxLocation.href = "";
8944 ajaxLocation = ajaxLocation.href;
8945}
8946
8947// Segment location into parts
8948ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
8949
8950// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
8951function addToPrefiltersOrTransports( structure ) {
8952
8953 // dataTypeExpression is optional and defaults to "*"
8954 return function( dataTypeExpression, func ) {
8955
8956  if ( typeof dataTypeExpression !== "string" ) {
8957   func = dataTypeExpression;
8958   dataTypeExpression = "*";
8959  }
8960
8961  var dataType,
8962   i = 0,
8963   dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
8964
8965  if ( jQuery.isFunction( func ) ) {
8966   // For each dataType in the dataTypeExpression
8967   while ( (dataType = dataTypes[i++]) ) {
8968    // Prepend if requested
8969    if ( dataType.charAt( 0 ) === "+" ) {
8970     dataType = dataType.slice( 1 ) || "*";
8971     (structure[ dataType ] = structure[ dataType ] || []).unshift( func );
8972
8973    // Otherwise append
8974    } else {
8975     (structure[ dataType ] = structure[ dataType ] || []).push( func );
8976    }
8977   }
8978  }
8979 };
8980}
8981
8982// Base inspection function for prefilters and transports
8983function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
8984
8985 var inspected = {},
8986  seekingTransport = ( structure === transports );
8987
8988 function inspect( dataType ) {
8989  var selected;
8990  inspected[ dataType ] = true;
8991  jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
8992   var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
8993   if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
8994    options.dataTypes.unshift( dataTypeOrTransport );
8995    inspect( dataTypeOrTransport );
8996    return false;
8997   } else if ( seekingTransport ) {
8998    return !( selected = dataTypeOrTransport );
8999   }
9000  });
9001  return selected;
9002 }
9003
9004 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
9005}
9006
9007// A special extend for ajax options
9008// that takes "flat" options (not to be deep extended)
9009// Fixes #9887
9010function ajaxExtend( target, src ) {
9011 var deep, key,
9012  flatOptions = jQuery.ajaxSettings.flatOptions || {};
9013
9014 for ( key in src ) {
9015  if ( src[ key ] !== undefined ) {
9016   ( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
9017  }
9018 }
9019 if ( deep ) {
9020  jQuery.extend( true, target, deep );
9021 }
9022
9023 return target;
9024}
9025
9026/* Handles responses to an ajax request:
9027 * - finds the right dataType (mediates between content-type and expected dataType)
9028 * - returns the corresponding response
9029 */
9030function ajaxHandleResponses( s, jqXHR, responses ) {
9031 var firstDataType, ct, finalDataType, type,
9032  contents = s.contents,
9033  dataTypes = s.dataTypes;
9034
9035 // Remove auto dataType and get content-type in the process
9036 while ( dataTypes[ 0 ] === "*" ) {
9037  dataTypes.shift();
9038  if ( ct === undefined ) {
9039   ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
9040  }
9041 }
9042
9043 // Check if we're dealing with a known content-type
9044 if ( ct ) {
9045  for ( type in contents ) {
9046   if ( contents[ type ] && contents[ type ].test( ct ) ) {
9047    dataTypes.unshift( type );
9048    break;
9049   }
9050  }
9051 }
9052
9053 // Check to see if we have a response for the expected dataType
9054 if ( dataTypes[ 0 ] in responses ) {
9055  finalDataType = dataTypes[ 0 ];
9056 } else {
9057  // Try convertible dataTypes
9058  for ( type in responses ) {
9059   if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
9060    finalDataType = type;
9061    break;
9062   }
9063   if ( !firstDataType ) {
9064    firstDataType = type;
9065   }
9066  }
9067  // Or just use first one
9068  finalDataType = finalDataType || firstDataType;
9069 }
9070
9071 // If we found a dataType
9072 // We add the dataType to the list if needed
9073 // and return the corresponding response
9074 if ( finalDataType ) {
9075  if ( finalDataType !== dataTypes[ 0 ] ) {
9076   dataTypes.unshift( finalDataType );
9077  }
9078  return responses[ finalDataType ];
9079 }
9080}
9081
9082/* Chain conversions given the request and the original response
9083 * Also sets the responseXXX fields on the jqXHR instance
9084 */
9085function ajaxConvert( s, response, jqXHR, isSuccess ) {
9086 var conv2, current, conv, tmp, prev,
9087  converters = {},
9088  // Work with a copy of dataTypes in case we need to modify it for conversion
9089  dataTypes = s.dataTypes.slice();
9090
9091 // Create converters map with lowercased keys
9092 if ( dataTypes[ 1 ] ) {
9093  for ( conv in s.converters ) {
9094   converters[ conv.toLowerCase() ] = s.converters[ conv ];
9095  }
9096 }
9097
9098 current = dataTypes.shift();
9099
9100 // Convert to each sequential dataType
9101 while ( current ) {
9102
9103  if ( s.responseFields[ current ] ) {
9104   jqXHR[ s.responseFields[ current ] ] = response;
9105  }
9106
9107  // Apply the dataFilter if provided
9108  if ( !prev && isSuccess && s.dataFilter ) {
9109   response = s.dataFilter( response, s.dataType );
9110  }
9111
9112  prev = current;
9113  current = dataTypes.shift();
9114
9115  if ( current ) {
9116
9117   // There's only work to do if current dataType is non-auto
9118   if ( current === "*" ) {
9119
9120    current = prev;
9121
9122   // Convert response if prev dataType is non-auto and differs from current
9123   } else if ( prev !== "*" && prev !== current ) {
9124
9125    // Seek a direct converter
9126    conv = converters[ prev + " " + current ] || converters[ "* " + current ];
9127
9128    // If none found, seek a pair
9129    if ( !conv ) {
9130     for ( conv2 in converters ) {
9131
9132      // If conv2 outputs current
9133      tmp = conv2.split( " " );
9134      if ( tmp[ 1 ] === current ) {
9135
9136       // If prev can be converted to accepted input
9137       conv = converters[ prev + " " + tmp[ 0 ] ] ||
9138        converters[ "* " + tmp[ 0 ] ];
9139       if ( conv ) {
9140        // Condense equivalence converters
9141        if ( conv === true ) {
9142         conv = converters[ conv2 ];
9143
9144        // Otherwise, insert the intermediate dataType
9145        } else if ( converters[ conv2 ] !== true ) {
9146         current = tmp[ 0 ];
9147         dataTypes.unshift( tmp[ 1 ] );
9148        }
9149        break;
9150       }
9151      }
9152     }
9153    }
9154
9155    // Apply converter (if not an equivalence)
9156    if ( conv !== true ) {
9157
9158     // Unless errors are allowed to bubble, catch and return them
9159     if ( conv && s[ "throws" ] ) {
9160      response = conv( response );
9161     } else {
9162      try {
9163       response = conv( response );
9164      } catch ( e ) {
9165       return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
9166      }
9167     }
9168    }
9169   }
9170  }
9171 }
9172
9173 return { state: "success", data: response };
9174}
9175
9176jQuery.extend({
9177
9178 // Counter for holding the number of active queries
9179 active: 0,
9180
9181 // Last-Modified header cache for next request
9182 lastModified: {},
9183 etag: {},
9184
9185 ajaxSettings: {
9186  url: ajaxLocation,
9187  type: "GET",
9188  isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
9189  global: true,
9190  processData: true,
9191  async: true,
9192  contentType: "application/x-www-form-urlencoded; charset=UTF-8",
9193  /*
9194  timeout: 0,
9195  data: null,
9196  dataType: null,
9197  username: null,
9198  password: null,
9199  cache: null,
9200  throws: false,
9201  traditional: false,
9202  headers: {},
9203  */
9204
9205  accepts: {
9206   "*": allTypes,
9207   text: "text/plain",
9208   html: "text/html",
9209   xml: "application/xml, text/xml",
9210   json: "application/json, text/javascript"
9211  },
9212
9213  contents: {
9214   xml: /xml/,
9215   html: /html/,
9216   json: /json/
9217  },
9218
9219  responseFields: {
9220   xml: "responseXML",
9221   text: "responseText",
9222   json: "responseJSON"
9223  },
9224
9225  // Data converters
9226  // Keys separate source (or catchall "*") and destination types with a single space
9227  converters: {
9228
9229   // Convert anything to text
9230   "* text": String,
9231
9232   // Text to html (true = no transformation)
9233   "text html": true,
9234
9235   // Evaluate text as a json expression
9236   "text json": jQuery.parseJSON,
9237
9238   // Parse text as xml
9239   "text xml": jQuery.parseXML
9240  },
9241
9242  // For options that shouldn't be deep extended:
9243  // you can add your own custom options here if
9244  // and when you create one that shouldn't be
9245  // deep extended (see ajaxExtend)
9246  flatOptions: {
9247   url: true,
9248   context: true
9249  }
9250 },
9251
9252 // Creates a full fledged settings object into target
9253 // with both ajaxSettings and settings fields.
9254 // If target is omitted, writes into ajaxSettings.
9255 ajaxSetup: function( target, settings ) {
9256  return settings ?
9257
9258   // Building a settings object
9259   ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
9260
9261   // Extending ajaxSettings
9262   ajaxExtend( jQuery.ajaxSettings, target );
9263 },
9264
9265 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
9266 ajaxTransport: addToPrefiltersOrTransports( transports ),
9267
9268 // Main method
9269 ajax: function( url, options ) {
9270
9271  // If url is an object, simulate pre-1.5 signature
9272  if ( typeof url === "object" ) {
9273   options = url;
9274   url = undefined;
9275  }
9276
9277  // Force options to be an object
9278  options = options || {};
9279
9280  var // Cross-domain detection vars
9281   parts,
9282   // Loop variable
9283   i,
9284   // URL without anti-cache param
9285   cacheURL,
9286   // Response headers as string
9287   responseHeadersString,
9288   // timeout handle
9289   timeoutTimer,
9290
9291   // To know if global events are to be dispatched
9292   fireGlobals,
9293
9294   transport,
9295   // Response headers
9296   responseHeaders,
9297   // Create the final options object
9298   s = jQuery.ajaxSetup( {}, options ),
9299   // Callbacks context
9300   callbackContext = s.context || s,
9301   // Context for global events is callbackContext if it is a DOM node or jQuery collection
9302   globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
9303    jQuery( callbackContext ) :
9304    jQuery.event,
9305   // Deferreds
9306   deferred = jQuery.Deferred(),
9307   completeDeferred = jQuery.Callbacks("once memory"),
9308   // Status-dependent callbacks
9309   statusCode = s.statusCode || {},
9310   // Headers (they are sent all at once)
9311   requestHeaders = {},
9312   requestHeadersNames = {},
9313   // The jqXHR state
9314   state = 0,
9315   // Default abort message
9316   strAbort = "canceled",
9317   // Fake xhr
9318   jqXHR = {
9319    readyState: 0,
9320
9321    // Builds headers hashtable if needed
9322    getResponseHeader: function( key ) {
9323     var match;
9324     if ( state === 2 ) {
9325      if ( !responseHeaders ) {
9326       responseHeaders = {};
9327       while ( (match = rheaders.exec( responseHeadersString )) ) {
9328        responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
9329       }
9330      }
9331      match = responseHeaders[ key.toLowerCase() ];
9332     }
9333     return match == null ? null : match;
9334    },
9335
9336    // Raw string
9337    getAllResponseHeaders: function() {
9338     return state === 2 ? responseHeadersString : null;
9339    },
9340
9341    // Caches the header
9342    setRequestHeader: function( name, value ) {
9343     var lname = name.toLowerCase();
9344     if ( !state ) {
9345      name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
9346      requestHeaders[ name ] = value;
9347     }
9348     return this;
9349    },
9350
9351    // Overrides response content-type header
9352    overrideMimeType: function( type ) {
9353     if ( !state ) {
9354      s.mimeType = type;
9355     }
9356     return this;
9357    },
9358
9359    // Status-dependent callbacks
9360    statusCode: function( map ) {
9361     var code;
9362     if ( map ) {
9363      if ( state < 2 ) {
9364       for ( code in map ) {
9365        // Lazy-add the new callback in a way that preserves old ones
9366        statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
9367       }
9368      } else {
9369       // Execute the appropriate callbacks
9370       jqXHR.always( map[ jqXHR.status ] );
9371      }
9372     }
9373     return this;
9374    },
9375
9376    // Cancel the request
9377    abort: function( statusText ) {
9378     var finalText = statusText || strAbort;
9379     if ( transport ) {
9380      transport.abort( finalText );
9381     }
9382     done( 0, finalText );
9383     return this;
9384    }
9385   };
9386
9387  // Attach deferreds
9388  deferred.promise( jqXHR ).complete = completeDeferred.add;
9389  jqXHR.success = jqXHR.done;
9390  jqXHR.error = jqXHR.fail;
9391
9392  // Remove hash character (#7531: and string promotion)
9393  // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
9394  // Handle falsy url in the settings object (#10093: consistency with old signature)
9395  // We also use the url parameter if available
9396  s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
9397
9398  // Alias method option to type as per ticket #12004
9399  s.type = options.method || options.type || s.method || s.type;
9400
9401  // Extract dataTypes list
9402  s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
9403
9404  // A cross-domain request is in order when we have a protocol:host:port mismatch
9405  if ( s.crossDomain == null ) {
9406   parts = rurl.exec( s.url.toLowerCase() );
9407   s.crossDomain = !!( parts &&
9408    ( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
9409     ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
9410      ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
9411   );
9412  }
9413
9414  // Convert data if not already a string
9415  if ( s.data && s.processData && typeof s.data !== "string" ) {
9416   s.data = jQuery.param( s.data, s.traditional );
9417  }
9418
9419  // Apply prefilters
9420  inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
9421
9422  // If request was aborted inside a prefilter, stop there
9423  if ( state === 2 ) {
9424   return jqXHR;
9425  }
9426
9427  // We can fire global events as of now if asked to
9428  fireGlobals = s.global;
9429
9430  // Watch for a new set of requests
9431  if ( fireGlobals && jQuery.active++ === 0 ) {
9432   jQuery.event.trigger("ajaxStart");
9433  }
9434
9435  // Uppercase the type
9436  s.type = s.type.toUpperCase();
9437
9438  // Determine if request has content
9439  s.hasContent = !rnoContent.test( s.type );
9440
9441  // Save the URL in case we're toying with the If-Modified-Since
9442  // and/or If-None-Match header later on
9443  cacheURL = s.url;
9444
9445  // More options handling for requests with no content
9446  if ( !s.hasContent ) {
9447
9448   // If data is available, append data to url
9449   if ( s.data ) {
9450    cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
9451    // #9682: remove data so that it's not used in an eventual retry
9452    delete s.data;
9453   }
9454
9455   // Add anti-cache in url if needed
9456   if ( s.cache === false ) {
9457    s.url = rts.test( cacheURL ) ?
9458
9459     // If there is already a '_' parameter, set its value
9460     cacheURL.replace( rts, "$1_=" + nonce++ ) :
9461
9462     // Otherwise add one to the end
9463     cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++;
9464   }
9465  }
9466
9467  // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9468  if ( s.ifModified ) {
9469   if ( jQuery.lastModified[ cacheURL ] ) {
9470    jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
9471   }
9472   if ( jQuery.etag[ cacheURL ] ) {
9473    jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
9474   }
9475  }
9476
9477  // Set the correct header, if data is being sent
9478  if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
9479   jqXHR.setRequestHeader( "Content-Type", s.contentType );
9480  }
9481
9482  // Set the Accepts header for the server, depending on the dataType
9483  jqXHR.setRequestHeader(
9484   "Accept",
9485   s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
9486    s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
9487    s.accepts[ "*" ]
9488  );
9489
9490  // Check for headers option
9491  for ( i in s.headers ) {
9492   jqXHR.setRequestHeader( i, s.headers[ i ] );
9493  }
9494
9495  // Allow custom headers/mimetypes and early abort
9496  if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
9497   // Abort if not done already and return
9498   return jqXHR.abort();
9499  }
9500
9501  // aborting is no longer a cancellation
9502  strAbort = "abort";
9503
9504  // Install callbacks on deferreds
9505  for ( i in { success: 1, error: 1, complete: 1 } ) {
9506   jqXHR[ i ]( s[ i ] );
9507  }
9508
9509  // Get transport
9510  transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
9511
9512  // If no transport, we auto-abort
9513  if ( !transport ) {
9514   done( -1, "No Transport" );
9515  } else {
9516   jqXHR.readyState = 1;
9517
9518   // Send global event
9519   if ( fireGlobals ) {
9520    globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
9521   }
9522   // Timeout
9523   if ( s.async && s.timeout > 0 ) {
9524    timeoutTimer = setTimeout(function() {
9525     jqXHR.abort("timeout");
9526    }, s.timeout );
9527   }
9528
9529   try {
9530    state = 1;
9531    transport.send( requestHeaders, done );
9532   } catch ( e ) {
9533    // Propagate exception as error if not done
9534    if ( state < 2 ) {
9535     done( -1, e );
9536    // Simply rethrow otherwise
9537    } else {
9538     throw e;
9539    }
9540   }
9541  }
9542
9543  // Callback for when everything is done
9544  function done( status, nativeStatusText, responses, headers ) {
9545   var isSuccess, success, error, response, modified,
9546    statusText = nativeStatusText;
9547
9548   // Called once
9549   if ( state === 2 ) {
9550    return;
9551   }
9552
9553   // State is "done" now
9554   state = 2;
9555
9556   // Clear timeout if it exists
9557   if ( timeoutTimer ) {
9558    clearTimeout( timeoutTimer );
9559   }
9560
9561   // Dereference transport for early garbage collection
9562   // (no matter how long the jqXHR object will be used)
9563   transport = undefined;
9564
9565   // Cache response headers
9566   responseHeadersString = headers || "";
9567
9568   // Set readyState
9569   jqXHR.readyState = status > 0 ? 4 : 0;
9570
9571   // Determine if successful
9572   isSuccess = status >= 200 && status < 300 || status === 304;
9573
9574   // Get response data
9575   if ( responses ) {
9576    response = ajaxHandleResponses( s, jqXHR, responses );
9577   }
9578
9579   // Convert no matter what (that way responseXXX fields are always set)
9580   response = ajaxConvert( s, response, jqXHR, isSuccess );
9581
9582   // If successful, handle type chaining
9583   if ( isSuccess ) {
9584
9585    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9586    if ( s.ifModified ) {
9587     modified = jqXHR.getResponseHeader("Last-Modified");
9588     if ( modified ) {
9589      jQuery.lastModified[ cacheURL ] = modified;
9590     }
9591     modified = jqXHR.getResponseHeader("etag");
9592     if ( modified ) {
9593      jQuery.etag[ cacheURL ] = modified;
9594     }
9595    }
9596
9597    // if no content
9598    if ( status === 204 || s.type === "HEAD" ) {
9599     statusText = "nocontent";
9600
9601    // if not modified
9602    } else if ( status === 304 ) {
9603     statusText = "notmodified";
9604
9605    // If we have data, let's convert it
9606    } else {
9607     statusText = response.state;
9608     success = response.data;
9609     error = response.error;
9610     isSuccess = !error;
9611    }
9612   } else {
9613    // We extract error from statusText
9614    // then normalize statusText and status for non-aborts
9615    error = statusText;
9616    if ( status || !statusText ) {
9617     statusText = "error";
9618     if ( status < 0 ) {
9619      status = 0;
9620     }
9621    }
9622   }
9623
9624   // Set data for the fake xhr object
9625   jqXHR.status = status;
9626   jqXHR.statusText = ( nativeStatusText || statusText ) + "";
9627
9628   // Success/Error
9629   if ( isSuccess ) {
9630    deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
9631   } else {
9632    deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
9633   }
9634
9635   // Status-dependent callbacks
9636   jqXHR.statusCode( statusCode );
9637   statusCode = undefined;
9638
9639   if ( fireGlobals ) {
9640    globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
9641     [ jqXHR, s, isSuccess ? success : error ] );
9642   }
9643
9644   // Complete
9645   completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
9646
9647   if ( fireGlobals ) {
9648    globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
9649    // Handle the global AJAX counter
9650    if ( !( --jQuery.active ) ) {
9651     jQuery.event.trigger("ajaxStop");
9652    }
9653   }
9654  }
9655
9656  return jqXHR;
9657 },
9658
9659 getJSON: function( url, data, callback ) {
9660  return jQuery.get( url, data, callback, "json" );
9661 },
9662
9663 getScript: function( url, callback ) {
9664  return jQuery.get( url, undefined, callback, "script" );
9665 }
9666});
9667
9668jQuery.each( [ "get", "post" ], function( i, method ) {
9669 jQuery[ method ] = function( url, data, callback, type ) {
9670  // shift arguments if data argument was omitted
9671  if ( jQuery.isFunction( data ) ) {
9672   type = type || callback;
9673   callback = data;
9674   data = undefined;
9675  }
9676
9677  return jQuery.ajax({
9678   url: url,
9679   type: method,
9680   dataType: type,
9681   data: data,
9682   success: callback
9683  });
9684 };
9685});
9686
9687// Attach a bunch of functions for handling common AJAX events
9688jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
9689 jQuery.fn[ type ] = function( fn ) {
9690  return this.on( type, fn );
9691 };
9692});
9693
9694jQuery._evalUrl = function( url ) {
9695 return jQuery.ajax({
9696  url: url,
9697  type: "GET",
9698  dataType: "script",
9699  async: false,
9700  global: false,
9701  "throws": true
9702 });
9703};
9704
9705jQuery.fn.extend({
9706 wrapAll: function( html ) {
9707  if ( jQuery.isFunction( html ) ) {
9708   return this.each(function(i) {
9709    jQuery(this).wrapAll( html.call(this, i) );
9710   });
9711  }
9712
9713  if ( this[0] ) {
9714   // The elements to wrap the target around
9715   var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
9716
9717   if ( this[0].parentNode ) {
9718    wrap.insertBefore( this[0] );
9719   }
9720
9721   wrap.map(function() {
9722    var elem = this;
9723
9724    while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
9725     elem = elem.firstChild;
9726    }
9727
9728    return elem;
9729   }).append( this );
9730  }
9731
9732  return this;
9733 },
9734
9735 wrapInner: function( html ) {
9736  if ( jQuery.isFunction( html ) ) {
9737   return this.each(function(i) {
9738    jQuery(this).wrapInner( html.call(this, i) );
9739   });
9740  }
9741
9742  return this.each(function() {
9743   var self = jQuery( this ),
9744    contents = self.contents();
9745
9746   if ( contents.length ) {
9747    contents.wrapAll( html );
9748
9749   } else {
9750    self.append( html );
9751   }
9752  });
9753 },
9754
9755 wrap: function( html ) {
9756  var isFunction = jQuery.isFunction( html );
9757
9758  return this.each(function(i) {
9759   jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
9760  });
9761 },
9762
9763 unwrap: function() {
9764  return this.parent().each(function() {
9765   if ( !jQuery.nodeName( this, "body" ) ) {
9766    jQuery( this ).replaceWith( this.childNodes );
9767   }
9768  }).end();
9769 }
9770});
9771
9772jQuery.expr.filters.hidden = function( elem ) {
9773 // Support: Opera <= 12.12
9774 // Opera reports offsetWidths and offsetHeights less than zero on some elements
9775 return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 ||
9776  (!support.reliableHiddenOffsets() &&
9777   ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
9778};
9779
9780jQuery.expr.filters.visible = function( elem ) {
9781 return !jQuery.expr.filters.hidden( elem );
9782};
9783
9784var r20 = /%20/g,
9785 rbracket = /\[\]$/,
9786 rCRLF = /\r?\n/g,
9787 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
9788 rsubmittable = /^(?:input|select|textarea|keygen)/i;
9789
9790function buildParams( prefix, obj, traditional, add ) {
9791 var name;
9792
9793 if ( jQuery.isArray( obj ) ) {
9794  // Serialize array item.
9795  jQuery.each( obj, function( i, v ) {
9796   if ( traditional || rbracket.test( prefix ) ) {
9797    // Treat each array item as a scalar.
9798    add( prefix, v );
9799
9800   } else {
9801    // Item is non-scalar (array or object), encode its numeric index.
9802    buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
9803   }
9804  });
9805
9806 } else if ( !traditional && jQuery.type( obj ) === "object" ) {
9807  // Serialize object item.
9808  for ( name in obj ) {
9809   buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
9810  }
9811
9812 } else {
9813  // Serialize scalar item.
9814  add( prefix, obj );
9815 }
9816}
9817
9818// Serialize an array of form elements or a set of
9819// key/values into a query string
9820jQuery.param = function( a, traditional ) {
9821 var prefix,
9822  s = [],
9823  add = function( key, value ) {
9824   // If value is a function, invoke it and return its value
9825   value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
9826   s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
9827  };
9828
9829 // Set traditional to true for jQuery <= 1.3.2 behavior.
9830 if ( traditional === undefined ) {
9831  traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
9832 }
9833
9834 // If an array was passed in, assume that it is an array of form elements.
9835 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
9836  // Serialize the form elements
9837  jQuery.each( a, function() {
9838   add( this.name, this.value );
9839  });
9840
9841 } else {
9842  // If traditional, encode the "old" way (the way 1.3.2 or older
9843  // did it), otherwise encode params recursively.
9844  for ( prefix in a ) {
9845   buildParams( prefix, a[ prefix ], traditional, add );
9846  }
9847 }
9848
9849 // Return the resulting serialization
9850 return s.join( "&" ).replace( r20, "+" );
9851};
9852
9853jQuery.fn.extend({
9854 serialize: function() {
9855  return jQuery.param( this.serializeArray() );
9856 },
9857 serializeArray: function() {
9858  return this.map(function() {
9859   // Can add propHook for "elements" to filter or add form elements
9860   var elements = jQuery.prop( this, "elements" );
9861   return elements ? jQuery.makeArray( elements ) : this;
9862  })
9863  .filter(function() {
9864   var type = this.type;
9865   // Use .is(":disabled") so that fieldset[disabled] works
9866   return this.name && !jQuery( this ).is( ":disabled" ) &&
9867    rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
9868    ( this.checked || !rcheckableType.test( type ) );
9869  })
9870  .map(function( i, elem ) {
9871   var val = jQuery( this ).val();
9872
9873   return val == null ?
9874    null :
9875    jQuery.isArray( val ) ?
9876     jQuery.map( val, function( val ) {
9877      return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
9878     }) :
9879     { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
9880  }).get();
9881 }
9882});
9883
9884// Create the request object
9885// (This is still attached to ajaxSettings for backward compatibility)
9886jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ?
9887 // Support: IE6+
9888 function() {
9889
9890  // XHR cannot access local files, always use ActiveX for that case
9891  return !this.isLocal &&
9892
9893   // Support: IE7-8
9894   // oldIE XHR does not support non-RFC2616 methods (#13240)
9895   // See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx
9896   // and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9
9897   // Although this check for six methods instead of eight
9898   // since IE also does not support "trace" and "connect"
9899   /^(get|post|head|put|delete|options)$/i.test( this.type ) &&
9900
9901   createStandardXHR() || createActiveXHR();
9902 } :
9903 // For all other browsers, use the standard XMLHttpRequest object
9904 createStandardXHR;
9905
9906var xhrId = 0,
9907 xhrCallbacks = {},
9908 xhrSupported = jQuery.ajaxSettings.xhr();
9909
9910// Support: IE<10
9911// Open requests must be manually aborted on unload (#5280)
9912if ( window.ActiveXObject ) {
9913 jQuery( window ).on( "unload", function() {
9914  for ( var key in xhrCallbacks ) {
9915   xhrCallbacks[ key ]( undefined, true );
9916  }
9917 });
9918}
9919
9920// Determine support properties
9921support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
9922xhrSupported = support.ajax = !!xhrSupported;
9923
9924// Create transport if the browser can provide an xhr
9925if ( xhrSupported ) {
9926
9927 jQuery.ajaxTransport(function( options ) {
9928  // Cross domain only allowed if supported through XMLHttpRequest
9929  if ( !options.crossDomain || support.cors ) {
9930
9931   var callback;
9932
9933   return {
9934    send: function( headers, complete ) {
9935     var i,
9936      xhr = options.xhr(),
9937      id = ++xhrId;
9938
9939     // Open the socket
9940     xhr.open( options.type, options.url, options.async, options.username, options.password );
9941
9942     // Apply custom fields if provided
9943     if ( options.xhrFields ) {
9944      for ( i in options.xhrFields ) {
9945       xhr[ i ] = options.xhrFields[ i ];
9946      }
9947     }
9948
9949     // Override mime type if needed
9950     if ( options.mimeType && xhr.overrideMimeType ) {
9951      xhr.overrideMimeType( options.mimeType );
9952     }
9953
9954     // X-Requested-With header
9955     // For cross-domain requests, seeing as conditions for a preflight are
9956     // akin to a jigsaw puzzle, we simply never set it to be sure.
9957     // (it can always be set on a per-request basis or even using ajaxSetup)
9958     // For same-domain requests, won't change header if already provided.
9959     if ( !options.crossDomain && !headers["X-Requested-With"] ) {
9960      headers["X-Requested-With"] = "XMLHttpRequest";
9961     }
9962
9963     // Set headers
9964     for ( i in headers ) {
9965      // Support: IE<9
9966      // IE's ActiveXObject throws a 'Type Mismatch' exception when setting
9967      // request header to a null-value.
9968      //
9969      // To keep consistent with other XHR implementations, cast the value
9970      // to string and ignore `undefined`.
9971      if ( headers[ i ] !== undefined ) {
9972       xhr.setRequestHeader( i, headers[ i ] + "" );
9973      }
9974     }
9975
9976     // Do send the request
9977     // This may raise an exception which is actually
9978     // handled in jQuery.ajax (so no try/catch here)
9979     xhr.send( ( options.hasContent && options.data ) || null );
9980
9981     // Listener
9982     callback = function( _, isAbort ) {
9983      var status, statusText, responses;
9984
9985      // Was never called and is aborted or complete
9986      if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
9987       // Clean up
9988       delete xhrCallbacks[ id ];
9989       callback = undefined;
9990       xhr.onreadystatechange = jQuery.noop;
9991
9992       // Abort manually if needed
9993       if ( isAbort ) {
9994        if ( xhr.readyState !== 4 ) {
9995         xhr.abort();
9996        }
9997       } else {
9998        responses = {};
9999        status = xhr.status;
10000
10001        // Support: IE<10
10002        // Accessing binary-data responseText throws an exception
10003        // (#11426)
10004        if ( typeof xhr.responseText === "string" ) {
10005         responses.text = xhr.responseText;
10006        }
10007
10008        // Firefox throws an exception when accessing
10009        // statusText for faulty cross-domain requests
10010        try {
10011         statusText = xhr.statusText;
10012        } catch( e ) {
10013         // We normalize with Webkit giving an empty statusText
10014         statusText = "";
10015        }
10016
10017        // Filter status for non standard behaviors
10018
10019        // If the request is local and we have data: assume a success
10020        // (success with no data won't get notified, that's the best we
10021        // can do given current implementations)
10022        if ( !status && options.isLocal && !options.crossDomain ) {
10023         status = responses.text ? 200 : 404;
10024        // IE - #1450: sometimes returns 1223 when it should be 204
10025        } else if ( status === 1223 ) {
10026         status = 204;
10027        }
10028       }
10029      }
10030
10031      // Call complete if needed
10032      if ( responses ) {
10033       complete( status, statusText, responses, xhr.getAllResponseHeaders() );
10034      }
10035     };
10036
10037     if ( !options.async ) {
10038      // if we're in sync mode we fire the callback
10039      callback();
10040     } else if ( xhr.readyState === 4 ) {
10041      // (IE6 & IE7) if it's in cache and has been
10042      // retrieved directly we need to fire the callback
10043      setTimeout( callback );
10044     } else {
10045      // Add to the list of active xhr callbacks
10046      xhr.onreadystatechange = xhrCallbacks[ id ] = callback;
10047     }
10048    },
10049
10050    abort: function() {
10051     if ( callback ) {
10052      callback( undefined, true );
10053     }
10054    }
10055   };
10056  }
10057 });
10058}
10059
10060// Functions to create xhrs
10061function createStandardXHR() {
10062 try {
10063  return new window.XMLHttpRequest();
10064 } catch( e ) {}
10065}
10066
10067function createActiveXHR() {
10068 try {
10069  return new window.ActiveXObject( "Microsoft.XMLHTTP" );
10070 } catch( e ) {}
10071}
10072
10073// Install script dataType
10074jQuery.ajaxSetup({
10075 accepts: {
10076  script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
10077 },
10078 contents: {
10079  script: /(?:java|ecma)script/
10080 },
10081 converters: {
10082  "text script": function( text ) {
10083   jQuery.globalEval( text );
10084   return text;
10085  }
10086 }
10087});
10088
10089// Handle cache's special case and global
10090jQuery.ajaxPrefilter( "script", function( s ) {
10091 if ( s.cache === undefined ) {
10092  s.cache = false;
10093 }
10094 if ( s.crossDomain ) {
10095  s.type = "GET";
10096  s.global = false;
10097 }
10098});
10099
10100// Bind script tag hack transport
10101jQuery.ajaxTransport( "script", function(s) {
10102
10103 // This transport only deals with cross domain requests
10104 if ( s.crossDomain ) {
10105
10106  var script,
10107   head = document.head || jQuery("head")[0] || document.documentElement;
10108
10109  return {
10110
10111   send: function( _, callback ) {
10112
10113    script = document.createElement("script");
10114
10115    script.async = true;
10116
10117    if ( s.scriptCharset ) {
10118     script.charset = s.scriptCharset;
10119    }
10120
10121    script.src = s.url;
10122
10123    // Attach handlers for all browsers
10124    script.onload = script.onreadystatechange = function( _, isAbort ) {
10125
10126     if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
10127
10128      // Handle memory leak in IE
10129      script.onload = script.onreadystatechange = null;
10130
10131      // Remove the script
10132      if ( script.parentNode ) {
10133       script.parentNode.removeChild( script );
10134      }
10135
10136      // Dereference the script
10137      script = null;
10138
10139      // Callback if not abort
10140      if ( !isAbort ) {
10141       callback( 200, "success" );
10142      }
10143     }
10144    };
10145
10146    // Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
10147    // Use native DOM manipulation to avoid our domManip AJAX trickery
10148    head.insertBefore( script, head.firstChild );
10149   },
10150
10151   abort: function() {
10152    if ( script ) {
10153     script.onload( undefined, true );
10154    }
10155   }
10156  };
10157 }
10158});
10159
10160var oldCallbacks = [],
10161 rjsonp = /(=)\?(?=&|$)|\?\?/;
10162
10163// Default jsonp settings
10164jQuery.ajaxSetup({
10165 jsonp: "callback",
10166 jsonpCallback: function() {
10167  var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
10168  this[ callback ] = true;
10169  return callback;
10170 }
10171});
10172
10173// Detect, normalize options and install callbacks for jsonp requests
10174jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
10175
10176 var callbackName, overwritten, responseContainer,
10177  jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
10178   "url" :
10179   typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
10180  );
10181
10182 // Handle iff the expected data type is "jsonp" or we have a parameter to set
10183 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
10184
10185  // Get callback name, remembering preexisting value associated with it
10186  callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
10187   s.jsonpCallback() :
10188   s.jsonpCallback;
10189
10190  // Insert callback into url or form data
10191  if ( jsonProp ) {
10192   s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
10193  } else if ( s.jsonp !== false ) {
10194   s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
10195  }
10196
10197  // Use data converter to retrieve json after script execution
10198  s.converters["script json"] = function() {
10199   if ( !responseContainer ) {
10200    jQuery.error( callbackName + " was not called" );
10201   }
10202   return responseContainer[ 0 ];
10203  };
10204
10205  // force json dataType
10206  s.dataTypes[ 0 ] = "json";
10207
10208  // Install callback
10209  overwritten = window[ callbackName ];
10210  window[ callbackName ] = function() {
10211   responseContainer = arguments;
10212  };
10213
10214  // Clean-up function (fires after converters)
10215  jqXHR.always(function() {
10216   // Restore preexisting value
10217   window[ callbackName ] = overwritten;
10218
10219   // Save back as free
10220   if ( s[ callbackName ] ) {
10221    // make sure that re-using the options doesn't screw things around
10222    s.jsonpCallback = originalSettings.jsonpCallback;
10223
10224    // save the callback name for future use
10225    oldCallbacks.push( callbackName );
10226   }
10227
10228   // Call if it was a function and we have a response
10229   if ( responseContainer && jQuery.isFunction( overwritten ) ) {
10230    overwritten( responseContainer[ 0 ] );
10231   }
10232
10233   responseContainer = overwritten = undefined;
10234  });
10235
10236  // Delegate to script
10237  return "script";
10238 }
10239});
10240
10241// data: string of html
10242// context (optional): If specified, the fragment will be created in this context, defaults to document
10243// keepScripts (optional): If true, will include scripts passed in the html string
10244jQuery.parseHTML = function( data, context, keepScripts ) {
10245 if ( !data || typeof data !== "string" ) {
10246  return null;
10247 }
10248 if ( typeof context === "boolean" ) {
10249  keepScripts = context;
10250  context = false;
10251 }
10252 context = context || document;
10253
10254 var parsed = rsingleTag.exec( data ),
10255  scripts = !keepScripts && [];
10256
10257 // Single tag
10258 if ( parsed ) {
10259  return [ context.createElement( parsed[1] ) ];
10260 }
10261
10262 parsed = jQuery.buildFragment( [ data ], context, scripts );
10263
10264 if ( scripts && scripts.length ) {
10265  jQuery( scripts ).remove();
10266 }
10267
10268 return jQuery.merge( [], parsed.childNodes );
10269};
10270
10271// Keep a copy of the old load method
10272var _load = jQuery.fn.load;
10273
10274/**
10275 * Load a url into a page
10276 */
10277jQuery.fn.load = function( url, params, callback ) {
10278 if ( typeof url !== "string" && _load ) {
10279  return _load.apply( this, arguments );
10280 }
10281
10282 var selector, response, type,
10283  self = this,
10284  off = url.indexOf(" ");
10285
10286 if ( off >= 0 ) {
10287  selector = jQuery.trim( url.slice( off, url.length ) );
10288  url = url.slice( 0, off );
10289 }
10290
10291 // If it's a function
10292 if ( jQuery.isFunction( params ) ) {
10293
10294  // We assume that it's the callback
10295  callback = params;
10296  params = undefined;
10297
10298 // Otherwise, build a param string
10299 } else if ( params && typeof params === "object" ) {
10300  type = "POST";
10301 }
10302
10303 // If we have elements to modify, make the request
10304 if ( self.length > 0 ) {
10305  jQuery.ajax({
10306   url: url,
10307
10308   // if "type" variable is undefined, then "GET" method will be used
10309   type: type,
10310   dataType: "html",
10311   data: params
10312  }).done(function( responseText ) {
10313
10314   // Save response for use in complete callback
10315   response = arguments;
10316
10317   self.html( selector ?
10318
10319    // If a selector was specified, locate the right elements in a dummy div
10320    // Exclude scripts to avoid IE 'Permission Denied' errors
10321    jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :
10322
10323    // Otherwise use the full result
10324    responseText );
10325
10326  }).complete( callback && function( jqXHR, status ) {
10327   self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
10328  });
10329 }
10330
10331 return this;
10332};
10333
10334jQuery.expr.filters.animated = function( elem ) {
10335 return jQuery.grep(jQuery.timers, function( fn ) {
10336  return elem === fn.elem;
10337 }).length;
10338};
10339
10340var docElem = window.document.documentElement;
10341
10342/**
10343 * Gets a window from an element
10344 */
10345function getWindow( elem ) {
10346 return jQuery.isWindow( elem ) ?
10347  elem :
10348  elem.nodeType === 9 ?
10349   elem.defaultView || elem.parentWindow :
10350   false;
10351}
10352
10353jQuery.offset = {
10354 setOffset: function( elem, options, i ) {
10355  var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
10356   position = jQuery.css( elem, "position" ),
10357   curElem = jQuery( elem ),
10358   props = {};
10359
10360  // set position first, in-case top/left are set even on static elem
10361  if ( position === "static" ) {
10362   elem.style.position = "relative";
10363  }
10364
10365  curOffset = curElem.offset();
10366  curCSSTop = jQuery.css( elem, "top" );
10367  curCSSLeft = jQuery.css( elem, "left" );
10368  calculatePosition = ( position === "absolute" || position === "fixed" ) &&
10369   jQuery.inArray("auto", [ curCSSTop, curCSSLeft ] ) > -1;
10370
10371  // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
10372  if ( calculatePosition ) {
10373   curPosition = curElem.position();
10374   curTop = curPosition.top;
10375   curLeft = curPosition.left;
10376  } else {
10377   curTop = parseFloat( curCSSTop ) || 0;
10378   curLeft = parseFloat( curCSSLeft ) || 0;
10379  }
10380
10381  if ( jQuery.isFunction( options ) ) {
10382   options = options.call( elem, i, curOffset );
10383  }
10384
10385  if ( options.top != null ) {
10386   props.top = ( options.top - curOffset.top ) + curTop;
10387  }
10388  if ( options.left != null ) {
10389   props.left = ( options.left - curOffset.left ) + curLeft;
10390  }
10391
10392  if ( "using" in options ) {
10393   options.using.call( elem, props );
10394  } else {
10395   curElem.css( props );
10396  }
10397 }
10398};
10399
10400jQuery.fn.extend({
10401 offset: function( options ) {
10402  if ( arguments.length ) {
10403   return options === undefined ?
10404    this :
10405    this.each(function( i ) {
10406     jQuery.offset.setOffset( this, options, i );
10407    });
10408  }
10409
10410  var docElem, win,
10411   box = { top: 0, left: 0 },
10412   elem = this[ 0 ],
10413   doc = elem && elem.ownerDocument;
10414
10415  if ( !doc ) {
10416   return;
10417  }
10418
10419  docElem = doc.documentElement;
10420
10421  // Make sure it's not a disconnected DOM node
10422  if ( !jQuery.contains( docElem, elem ) ) {
10423   return box;
10424  }
10425
10426  // If we don't have gBCR, just use 0,0 rather than error
10427  // BlackBerry 5, iOS 3 (original iPhone)
10428  if ( typeof elem.getBoundingClientRect !== strundefined ) {
10429   box = elem.getBoundingClientRect();
10430  }
10431  win = getWindow( doc );
10432  return {
10433   top: box.top  + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ),
10434   left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
10435  };
10436 },
10437
10438 position: function() {
10439  if ( !this[ 0 ] ) {
10440   return;
10441  }
10442
10443  var offsetParent, offset,
10444   parentOffset = { top: 0, left: 0 },
10445   elem = this[ 0 ];
10446
10447  // fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent
10448  if ( jQuery.css( elem, "position" ) === "fixed" ) {
10449   // we assume that getBoundingClientRect is available when computed position is fixed
10450   offset = elem.getBoundingClientRect();
10451  } else {
10452   // Get *real* offsetParent
10453   offsetParent = this.offsetParent();
10454
10455   // Get correct offsets
10456   offset = this.offset();
10457   if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
10458    parentOffset = offsetParent.offset();
10459   }
10460
10461   // Add offsetParent borders
10462   parentOffset.top  += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
10463   parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
10464  }
10465
10466  // Subtract parent offsets and element margins
10467  // note: when an element has margin: auto the offsetLeft and marginLeft
10468  // are the same in Safari causing offset.left to incorrectly be 0
10469  return {
10470   top:  offset.top  - parentOffset.top - jQuery.css( elem, "marginTop", true ),
10471   left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true)
10472  };
10473 },
10474
10475 offsetParent: function() {
10476  return this.map(function() {
10477   var offsetParent = this.offsetParent || docElem;
10478
10479   while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position" ) === "static" ) ) {
10480    offsetParent = offsetParent.offsetParent;
10481   }
10482   return offsetParent || docElem;
10483  });
10484 }
10485});
10486
10487// Create scrollLeft and scrollTop methods
10488jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
10489 var top = /Y/.test( prop );
10490
10491 jQuery.fn[ method ] = function( val ) {
10492  return access( this, function( elem, method, val ) {
10493   var win = getWindow( elem );
10494
10495   if ( val === undefined ) {
10496    return win ? (prop in win) ? win[ prop ] :
10497     win.document.documentElement[ method ] :
10498     elem[ method ];
10499   }
10500
10501   if ( win ) {
10502    win.scrollTo(
10503     !top ? val : jQuery( win ).scrollLeft(),
10504     top ? val : jQuery( win ).scrollTop()
10505    );
10506
10507   } else {
10508    elem[ method ] = val;
10509   }
10510  }, method, val, arguments.length, null );
10511 };
10512});
10513
10514// Add the top/left cssHooks using jQuery.fn.position
10515// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10516// getComputedStyle returns percent when specified for top/left/bottom/right
10517// rather than make the css module depend on the offset module, we just check for it here
10518jQuery.each( [ "top", "left" ], function( i, prop ) {
10519 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
10520  function( elem, computed ) {
10521   if ( computed ) {
10522    computed = curCSS( elem, prop );
10523    // if curCSS returns percentage, fallback to offset
10524    return rnumnonpx.test( computed ) ?
10525     jQuery( elem ).position()[ prop ] + "px" :
10526     computed;
10527   }
10528  }
10529 );
10530});
10531
10532// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10533jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
10534 jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
10535  // margin is only for outerHeight, outerWidth
10536  jQuery.fn[ funcName ] = function( margin, value ) {
10537   var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
10538    extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
10539
10540   return access( this, function( elem, type, value ) {
10541    var doc;
10542
10543    if ( jQuery.isWindow( elem ) ) {
10544     // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
10545     // isn't a whole lot we can do. See pull request at this URL for discussion:
10546     // https://github.com/jquery/jquery/pull/764
10547     return elem.document.documentElement[ "client" + name ];
10548    }
10549
10550    // Get document width or height
10551    if ( elem.nodeType === 9 ) {
10552     doc = elem.documentElement;
10553
10554     // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
10555     // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
10556     return Math.max(
10557      elem.body[ "scroll" + name ], doc[ "scroll" + name ],
10558      elem.body[ "offset" + name ], doc[ "offset" + name ],
10559      doc[ "client" + name ]
10560     );
10561    }
10562
10563    return value === undefined ?
10564     // Get width or height on the element, requesting but not forcing parseFloat
10565     jQuery.css( elem, type, extra ) :
10566
10567     // Set width or height on the element
10568     jQuery.style( elem, type, value, extra );
10569   }, type, chainable ? margin : undefined, chainable, null );
10570  };
10571 });
10572});
10573
10574// The number of elements contained in the matched element set
10575jQuery.fn.size = function() {
10576 return this.length;
10577};
10578
10579jQuery.fn.andSelf = jQuery.fn.addBack;
10580
10581// Register as a named AMD module, since jQuery can be concatenated with other
10582// files that may use define, but not via a proper concatenation script that
10583// understands anonymous AMD modules. A named AMD is safest and most robust
10584// way to register. Lowercase jquery is used because AMD module names are
10585// derived from file names, and jQuery is normally delivered in a lowercase
10586// file name. Do this after creating the global so that if an AMD module wants
10587// to call noConflict to hide this version of jQuery, it will work.
10588
10589// Note that for maximum portability, libraries that are not jQuery should
10590// declare themselves as anonymous modules, and avoid setting a global if an
10591// AMD loader is present. jQuery is a special case. For more information, see