Strabon
changeset 605:3e0f14b9bcd4
Added more button when displaying literals which have large length, for example geometries.
author | Stella Giannakopoulou <sgian@di.uoa.gr> |
---|---|
date | Tue Oct 02 18:35:44 2012 +0300 (2012-10-02) |
parents | 06a1beb9b9c3 |
children | b060242046c2 |
files | endpoint/WebContent/browse.jsp endpoint/WebContent/js/more_link.js endpoint/WebContent/query.jsp endpoint/WebContent/style.css resultio/src/main/java/org/openrdf/query/resultio/sparqlhtml/stSPARQLResultsHTMLWriter.java |
line diff
1.1 --- a/endpoint/WebContent/browse.jsp Tue Oct 02 15:12:45 2012 +0300 1.2 +++ b/endpoint/WebContent/browse.jsp Tue Oct 02 18:35:44 2012 +0300 1.3 @@ -13,7 +13,43 @@ 1.4 <meta name="viewport" content="initial-scale=1.0, user-scalable=no" /> 1.5 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> 1.6 <link rel="stylesheet" href="style.css" type="text/css" /> 1.7 + <script type="text/javascript" src="js/more_link.js"></script> 1.8 <title>TELEIOS: Strabon Endpoint</title> 1.9 + <script> 1.10 + $(document).ready(function() { 1.11 + var showChar = 100; 1.12 + var ellipsestext = "..."; 1.13 + var moretext = "more"; 1.14 + var lesstext = "less"; 1.15 + $('.more').each(function() { 1.16 + var content = $(this).html(); 1.17 + 1.18 + if(content.length > showChar) { 1.19 + 1.20 + var c = content.substr(0, showChar); 1.21 + var h = content.substr(showChar-1, content.length - showChar); 1.22 + 1.23 + var html = c + '<span class="moreelipses">'+ellipsestext+'</span> <span class="morecontent"><span>' + h + '</span> <a href="" class="morelink">'+moretext+'</a></span>'; 1.24 + 1.25 + $(this).html(html); 1.26 + } 1.27 + 1.28 + }); 1.29 + 1.30 + $(".morelink").click(function(){ 1.31 + if($(this).hasClass("less")) { 1.32 + $(this).removeClass("less"); 1.33 + $(this).html(moretext); 1.34 + } else { 1.35 + $(this).addClass("less"); 1.36 + $(this).html(lesstext); 1.37 + } 1.38 + $(this).parent().prev().toggle(); 1.39 + $(this).prev().toggle(); 1.40 + return false; 1.41 + }); 1.42 + }); 1.43 +</script> 1.44 </head> 1.45 <body topmargin="0" leftmargin="0" link="#FFFFFF" vlink="#FFFFFF" alink="#FFFFFF"> 1.46 <TABLE width="80%" BORDER=0 CELLPADDING=0 CELLSPACING=0> 1.47 @@ -36,7 +72,7 @@ 1.48 <h1>About: </h1> 1.49 <a href=""><%=request.getAttribute("resource")%></a> 1.50 <div id="response"> 1.51 - <!-- Response --> 1.52 + <!-- Response --> 1.53 <% if (request.getAttribute("response") != null) { 1.54 if (Common.getHTMLFormat().equals(request.getParameter("format"))) {%> 1.55 <%=request.getAttribute("response")%> 1.56 @@ -46,4 +82,5 @@ 1.57 <%}%> 1.58 </div> 1.59 </body> 1.60 + 1.61 </html> 1.62 \ No newline at end of file
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 2.2 +++ b/endpoint/WebContent/js/more_link.js Tue Oct 02 18:35:44 2012 +0300 2.3 @@ -0,0 +1,9440 @@ 2.4 +/*! 2.5 + * jQuery JavaScript Library v1.8.2 2.6 + * http://jquery.com/ 2.7 + * 2.8 + * Includes Sizzle.js 2.9 + * http://sizzlejs.com/ 2.10 + * 2.11 + * Copyright 2012 jQuery Foundation and other contributors 2.12 + * Released under the MIT license 2.13 + * http://jquery.org/license 2.14 + * 2.15 + * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time) 2.16 + */ 2.17 +(function( window, undefined ) { 2.18 +var 2.19 + // A central reference to the root jQuery(document) 2.20 + rootjQuery, 2.21 + 2.22 + // The deferred used on DOM ready 2.23 + readyList, 2.24 + 2.25 + // Use the correct document accordingly with window argument (sandbox) 2.26 + document = window.document, 2.27 + location = window.location, 2.28 + navigator = window.navigator, 2.29 + 2.30 + // Map over jQuery in case of overwrite 2.31 + _jQuery = window.jQuery, 2.32 + 2.33 + // Map over the $ in case of overwrite 2.34 + _$ = window.$, 2.35 + 2.36 + // Save a reference to some core methods 2.37 + core_push = Array.prototype.push, 2.38 + core_slice = Array.prototype.slice, 2.39 + core_indexOf = Array.prototype.indexOf, 2.40 + core_toString = Object.prototype.toString, 2.41 + core_hasOwn = Object.prototype.hasOwnProperty, 2.42 + core_trim = String.prototype.trim, 2.43 + 2.44 + // Define a local copy of jQuery 2.45 + jQuery = function( selector, context ) { 2.46 + // The jQuery object is actually just the init constructor 'enhanced' 2.47 + return new jQuery.fn.init( selector, context, rootjQuery ); 2.48 + }, 2.49 + 2.50 + // Used for matching numbers 2.51 + core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source, 2.52 + 2.53 + // Used for detecting and trimming whitespace 2.54 + core_rnotwhite = /\S/, 2.55 + core_rspace = /\s+/, 2.56 + 2.57 + // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE) 2.58 + rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, 2.59 + 2.60 + // A simple way to check for HTML strings 2.61 + // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) 2.62 + rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, 2.63 + 2.64 + // Match a standalone tag 2.65 + rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, 2.66 + 2.67 + // JSON RegExp 2.68 + rvalidchars = /^[\],:{}\s]*$/, 2.69 + rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, 2.70 + rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, 2.71 + rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g, 2.72 + 2.73 + // Matches dashed string for camelizing 2.74 + rmsPrefix = /^-ms-/, 2.75 + rdashAlpha = /-([\da-z])/gi, 2.76 + 2.77 + // Used by jQuery.camelCase as callback to replace() 2.78 + fcamelCase = function( all, letter ) { 2.79 + return ( letter + "" ).toUpperCase(); 2.80 + }, 2.81 + 2.82 + // The ready event handler and self cleanup method 2.83 + DOMContentLoaded = function() { 2.84 + if ( document.addEventListener ) { 2.85 + document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 2.86 + jQuery.ready(); 2.87 + } else if ( document.readyState === "complete" ) { 2.88 + // we're here because readyState === "complete" in oldIE 2.89 + // which is good enough for us to call the dom ready! 2.90 + document.detachEvent( "onreadystatechange", DOMContentLoaded ); 2.91 + jQuery.ready(); 2.92 + } 2.93 + }, 2.94 + 2.95 + // [[Class]] -> type pairs 2.96 + class2type = {}; 2.97 + 2.98 +jQuery.fn = jQuery.prototype = { 2.99 + constructor: jQuery, 2.100 + init: function( selector, context, rootjQuery ) { 2.101 + var match, elem, ret, doc; 2.102 + 2.103 + // Handle $(""), $(null), $(undefined), $(false) 2.104 + if ( !selector ) { 2.105 + return this; 2.106 + } 2.107 + 2.108 + // Handle $(DOMElement) 2.109 + if ( selector.nodeType ) { 2.110 + this.context = this[0] = selector; 2.111 + this.length = 1; 2.112 + return this; 2.113 + } 2.114 + 2.115 + // Handle HTML strings 2.116 + if ( typeof selector === "string" ) { 2.117 + if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { 2.118 + // Assume that strings that start and end with <> are HTML and skip the regex check 2.119 + match = [ null, selector, null ]; 2.120 + 2.121 + } else { 2.122 + match = rquickExpr.exec( selector ); 2.123 + } 2.124 + 2.125 + // Match html or make sure no context is specified for #id 2.126 + if ( match && (match[1] || !context) ) { 2.127 + 2.128 + // HANDLE: $(html) -> $(array) 2.129 + if ( match[1] ) { 2.130 + context = context instanceof jQuery ? context[0] : context; 2.131 + doc = ( context && context.nodeType ? context.ownerDocument || context : document ); 2.132 + 2.133 + // scripts is true for back-compat 2.134 + selector = jQuery.parseHTML( match[1], doc, true ); 2.135 + if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) { 2.136 + this.attr.call( selector, context, true ); 2.137 + } 2.138 + 2.139 + return jQuery.merge( this, selector ); 2.140 + 2.141 + // HANDLE: $(#id) 2.142 + } else { 2.143 + elem = document.getElementById( match[2] ); 2.144 + 2.145 + // Check parentNode to catch when Blackberry 4.6 returns 2.146 + // nodes that are no longer in the document #6963 2.147 + if ( elem && elem.parentNode ) { 2.148 + // Handle the case where IE and Opera return items 2.149 + // by name instead of ID 2.150 + if ( elem.id !== match[2] ) { 2.151 + return rootjQuery.find( selector ); 2.152 + } 2.153 + 2.154 + // Otherwise, we inject the element directly into the jQuery object 2.155 + this.length = 1; 2.156 + this[0] = elem; 2.157 + } 2.158 + 2.159 + this.context = document; 2.160 + this.selector = selector; 2.161 + return this; 2.162 + } 2.163 + 2.164 + // HANDLE: $(expr, $(...)) 2.165 + } else if ( !context || context.jquery ) { 2.166 + return ( context || rootjQuery ).find( selector ); 2.167 + 2.168 + // HANDLE: $(expr, context) 2.169 + // (which is just equivalent to: $(context).find(expr) 2.170 + } else { 2.171 + return this.constructor( context ).find( selector ); 2.172 + } 2.173 + 2.174 + // HANDLE: $(function) 2.175 + // Shortcut for document ready 2.176 + } else if ( jQuery.isFunction( selector ) ) { 2.177 + return rootjQuery.ready( selector ); 2.178 + } 2.179 + 2.180 + if ( selector.selector !== undefined ) { 2.181 + this.selector = selector.selector; 2.182 + this.context = selector.context; 2.183 + } 2.184 + 2.185 + return jQuery.makeArray( selector, this ); 2.186 + }, 2.187 + 2.188 + // Start with an empty selector 2.189 + selector: "", 2.190 + 2.191 + // The current version of jQuery being used 2.192 + jquery: "1.8.2", 2.193 + 2.194 + // The default length of a jQuery object is 0 2.195 + length: 0, 2.196 + 2.197 + // The number of elements contained in the matched element set 2.198 + size: function() { 2.199 + return this.length; 2.200 + }, 2.201 + 2.202 + toArray: function() { 2.203 + return core_slice.call( this ); 2.204 + }, 2.205 + 2.206 + // Get the Nth element in the matched element set OR 2.207 + // Get the whole matched element set as a clean array 2.208 + get: function( num ) { 2.209 + return num == null ? 2.210 + 2.211 + // Return a 'clean' array 2.212 + this.toArray() : 2.213 + 2.214 + // Return just the object 2.215 + ( num < 0 ? this[ this.length + num ] : this[ num ] ); 2.216 + }, 2.217 + 2.218 + // Take an array of elements and push it onto the stack 2.219 + // (returning the new matched element set) 2.220 + pushStack: function( elems, name, selector ) { 2.221 + 2.222 + // Build a new jQuery matched element set 2.223 + var ret = jQuery.merge( this.constructor(), elems ); 2.224 + 2.225 + // Add the old object onto the stack (as a reference) 2.226 + ret.prevObject = this; 2.227 + 2.228 + ret.context = this.context; 2.229 + 2.230 + if ( name === "find" ) { 2.231 + ret.selector = this.selector + ( this.selector ? " " : "" ) + selector; 2.232 + } else if ( name ) { 2.233 + ret.selector = this.selector + "." + name + "(" + selector + ")"; 2.234 + } 2.235 + 2.236 + // Return the newly-formed element set 2.237 + return ret; 2.238 + }, 2.239 + 2.240 + // Execute a callback for every element in the matched set. 2.241 + // (You can seed the arguments with an array of args, but this is 2.242 + // only used internally.) 2.243 + each: function( callback, args ) { 2.244 + return jQuery.each( this, callback, args ); 2.245 + }, 2.246 + 2.247 + ready: function( fn ) { 2.248 + // Add the callback 2.249 + jQuery.ready.promise().done( fn ); 2.250 + 2.251 + return this; 2.252 + }, 2.253 + 2.254 + eq: function( i ) { 2.255 + i = +i; 2.256 + return i === -1 ? 2.257 + this.slice( i ) : 2.258 + this.slice( i, i + 1 ); 2.259 + }, 2.260 + 2.261 + first: function() { 2.262 + return this.eq( 0 ); 2.263 + }, 2.264 + 2.265 + last: function() { 2.266 + return this.eq( -1 ); 2.267 + }, 2.268 + 2.269 + slice: function() { 2.270 + return this.pushStack( core_slice.apply( this, arguments ), 2.271 + "slice", core_slice.call(arguments).join(",") ); 2.272 + }, 2.273 + 2.274 + map: function( callback ) { 2.275 + return this.pushStack( jQuery.map(this, function( elem, i ) { 2.276 + return callback.call( elem, i, elem ); 2.277 + })); 2.278 + }, 2.279 + 2.280 + end: function() { 2.281 + return this.prevObject || this.constructor(null); 2.282 + }, 2.283 + 2.284 + // For internal use only. 2.285 + // Behaves like an Array's method, not like a jQuery method. 2.286 + push: core_push, 2.287 + sort: [].sort, 2.288 + splice: [].splice 2.289 +}; 2.290 + 2.291 +// Give the init function the jQuery prototype for later instantiation 2.292 +jQuery.fn.init.prototype = jQuery.fn; 2.293 + 2.294 +jQuery.extend = jQuery.fn.extend = function() { 2.295 + var options, name, src, copy, copyIsArray, clone, 2.296 + target = arguments[0] || {}, 2.297 + i = 1, 2.298 + length = arguments.length, 2.299 + deep = false; 2.300 + 2.301 + // Handle a deep copy situation 2.302 + if ( typeof target === "boolean" ) { 2.303 + deep = target; 2.304 + target = arguments[1] || {}; 2.305 + // skip the boolean and the target 2.306 + i = 2; 2.307 + } 2.308 + 2.309 + // Handle case when target is a string or something (possible in deep copy) 2.310 + if ( typeof target !== "object" && !jQuery.isFunction(target) ) { 2.311 + target = {}; 2.312 + } 2.313 + 2.314 + // extend jQuery itself if only one argument is passed 2.315 + if ( length === i ) { 2.316 + target = this; 2.317 + --i; 2.318 + } 2.319 + 2.320 + for ( ; i < length; i++ ) { 2.321 + // Only deal with non-null/undefined values 2.322 + if ( (options = arguments[ i ]) != null ) { 2.323 + // Extend the base object 2.324 + for ( name in options ) { 2.325 + src = target[ name ]; 2.326 + copy = options[ name ]; 2.327 + 2.328 + // Prevent never-ending loop 2.329 + if ( target === copy ) { 2.330 + continue; 2.331 + } 2.332 + 2.333 + // Recurse if we're merging plain objects or arrays 2.334 + if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { 2.335 + if ( copyIsArray ) { 2.336 + copyIsArray = false; 2.337 + clone = src && jQuery.isArray(src) ? src : []; 2.338 + 2.339 + } else { 2.340 + clone = src && jQuery.isPlainObject(src) ? src : {}; 2.341 + } 2.342 + 2.343 + // Never move original objects, clone them 2.344 + target[ name ] = jQuery.extend( deep, clone, copy ); 2.345 + 2.346 + // Don't bring in undefined values 2.347 + } else if ( copy !== undefined ) { 2.348 + target[ name ] = copy; 2.349 + } 2.350 + } 2.351 + } 2.352 + } 2.353 + 2.354 + // Return the modified object 2.355 + return target; 2.356 +}; 2.357 + 2.358 +jQuery.extend({ 2.359 + noConflict: function( deep ) { 2.360 + if ( window.$ === jQuery ) { 2.361 + window.$ = _$; 2.362 + } 2.363 + 2.364 + if ( deep && window.jQuery === jQuery ) { 2.365 + window.jQuery = _jQuery; 2.366 + } 2.367 + 2.368 + return jQuery; 2.369 + }, 2.370 + 2.371 + // Is the DOM ready to be used? Set to true once it occurs. 2.372 + isReady: false, 2.373 + 2.374 + // A counter to track how many items to wait for before 2.375 + // the ready event fires. See #6781 2.376 + readyWait: 1, 2.377 + 2.378 + // Hold (or release) the ready event 2.379 + holdReady: function( hold ) { 2.380 + if ( hold ) { 2.381 + jQuery.readyWait++; 2.382 + } else { 2.383 + jQuery.ready( true ); 2.384 + } 2.385 + }, 2.386 + 2.387 + // Handle when the DOM is ready 2.388 + ready: function( wait ) { 2.389 + 2.390 + // Abort if there are pending holds or we're already ready 2.391 + if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { 2.392 + return; 2.393 + } 2.394 + 2.395 + // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 2.396 + if ( !document.body ) { 2.397 + return setTimeout( jQuery.ready, 1 ); 2.398 + } 2.399 + 2.400 + // Remember that the DOM is ready 2.401 + jQuery.isReady = true; 2.402 + 2.403 + // If a normal DOM Ready event fired, decrement, and wait if need be 2.404 + if ( wait !== true && --jQuery.readyWait > 0 ) { 2.405 + return; 2.406 + } 2.407 + 2.408 + // If there are functions bound, to execute 2.409 + readyList.resolveWith( document, [ jQuery ] ); 2.410 + 2.411 + // Trigger any bound ready events 2.412 + if ( jQuery.fn.trigger ) { 2.413 + jQuery( document ).trigger("ready").off("ready"); 2.414 + } 2.415 + }, 2.416 + 2.417 + // See test/unit/core.js for details concerning isFunction. 2.418 + // Since version 1.3, DOM methods and functions like alert 2.419 + // aren't supported. They return false on IE (#2968). 2.420 + isFunction: function( obj ) { 2.421 + return jQuery.type(obj) === "function"; 2.422 + }, 2.423 + 2.424 + isArray: Array.isArray || function( obj ) { 2.425 + return jQuery.type(obj) === "array"; 2.426 + }, 2.427 + 2.428 + isWindow: function( obj ) { 2.429 + return obj != null && obj == obj.window; 2.430 + }, 2.431 + 2.432 + isNumeric: function( obj ) { 2.433 + return !isNaN( parseFloat(obj) ) && isFinite( obj ); 2.434 + }, 2.435 + 2.436 + type: function( obj ) { 2.437 + return obj == null ? 2.438 + String( obj ) : 2.439 + class2type[ core_toString.call(obj) ] || "object"; 2.440 + }, 2.441 + 2.442 + isPlainObject: function( obj ) { 2.443 + // Must be an Object. 2.444 + // Because of IE, we also have to check the presence of the constructor property. 2.445 + // Make sure that DOM nodes and window objects don't pass through, as well 2.446 + if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { 2.447 + return false; 2.448 + } 2.449 + 2.450 + try { 2.451 + // Not own constructor property must be Object 2.452 + if ( obj.constructor && 2.453 + !core_hasOwn.call(obj, "constructor") && 2.454 + !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { 2.455 + return false; 2.456 + } 2.457 + } catch ( e ) { 2.458 + // IE8,9 Will throw exceptions on certain host objects #9897 2.459 + return false; 2.460 + } 2.461 + 2.462 + // Own properties are enumerated firstly, so to speed up, 2.463 + // if last one is own, then all properties are own. 2.464 + 2.465 + var key; 2.466 + for ( key in obj ) {} 2.467 + 2.468 + return key === undefined || core_hasOwn.call( obj, key ); 2.469 + }, 2.470 + 2.471 + isEmptyObject: function( obj ) { 2.472 + var name; 2.473 + for ( name in obj ) { 2.474 + return false; 2.475 + } 2.476 + return true; 2.477 + }, 2.478 + 2.479 + error: function( msg ) { 2.480 + throw new Error( msg ); 2.481 + }, 2.482 + 2.483 + // data: string of html 2.484 + // context (optional): If specified, the fragment will be created in this context, defaults to document 2.485 + // scripts (optional): If true, will include scripts passed in the html string 2.486 + parseHTML: function( data, context, scripts ) { 2.487 + var parsed; 2.488 + if ( !data || typeof data !== "string" ) { 2.489 + return null; 2.490 + } 2.491 + if ( typeof context === "boolean" ) { 2.492 + scripts = context; 2.493 + context = 0; 2.494 + } 2.495 + context = context || document; 2.496 + 2.497 + // Single tag 2.498 + if ( (parsed = rsingleTag.exec( data )) ) { 2.499 + return [ context.createElement( parsed[1] ) ]; 2.500 + } 2.501 + 2.502 + parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] ); 2.503 + return jQuery.merge( [], 2.504 + (parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes ); 2.505 + }, 2.506 + 2.507 + parseJSON: function( data ) { 2.508 + if ( !data || typeof data !== "string") { 2.509 + return null; 2.510 + } 2.511 + 2.512 + // Make sure leading/trailing whitespace is removed (IE can't handle it) 2.513 + data = jQuery.trim( data ); 2.514 + 2.515 + // Attempt to parse using the native JSON parser first 2.516 + if ( window.JSON && window.JSON.parse ) { 2.517 + return window.JSON.parse( data ); 2.518 + } 2.519 + 2.520 + // Make sure the incoming data is actual JSON 2.521 + // Logic borrowed from http://json.org/json2.js 2.522 + if ( rvalidchars.test( data.replace( rvalidescape, "@" ) 2.523 + .replace( rvalidtokens, "]" ) 2.524 + .replace( rvalidbraces, "")) ) { 2.525 + 2.526 + return ( new Function( "return " + data ) )(); 2.527 + 2.528 + } 2.529 + jQuery.error( "Invalid JSON: " + data ); 2.530 + }, 2.531 + 2.532 + // Cross-browser xml parsing 2.533 + parseXML: function( data ) { 2.534 + var xml, tmp; 2.535 + if ( !data || typeof data !== "string" ) { 2.536 + return null; 2.537 + } 2.538 + try { 2.539 + if ( window.DOMParser ) { // Standard 2.540 + tmp = new DOMParser(); 2.541 + xml = tmp.parseFromString( data , "text/xml" ); 2.542 + } else { // IE 2.543 + xml = new ActiveXObject( "Microsoft.XMLDOM" ); 2.544 + xml.async = "false"; 2.545 + xml.loadXML( data ); 2.546 + } 2.547 + } catch( e ) { 2.548 + xml = undefined; 2.549 + } 2.550 + if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { 2.551 + jQuery.error( "Invalid XML: " + data ); 2.552 + } 2.553 + return xml; 2.554 + }, 2.555 + 2.556 + noop: function() {}, 2.557 + 2.558 + // Evaluates a script in a global context 2.559 + // Workarounds based on findings by Jim Driscoll 2.560 + // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context 2.561 + globalEval: function( data ) { 2.562 + if ( data && core_rnotwhite.test( data ) ) { 2.563 + // We use execScript on Internet Explorer 2.564 + // We use an anonymous function so that context is window 2.565 + // rather than jQuery in Firefox 2.566 + ( window.execScript || function( data ) { 2.567 + window[ "eval" ].call( window, data ); 2.568 + } )( data ); 2.569 + } 2.570 + }, 2.571 + 2.572 + // Convert dashed to camelCase; used by the css and data modules 2.573 + // Microsoft forgot to hump their vendor prefix (#9572) 2.574 + camelCase: function( string ) { 2.575 + return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); 2.576 + }, 2.577 + 2.578 + nodeName: function( elem, name ) { 2.579 + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 2.580 + }, 2.581 + 2.582 + // args is for internal usage only 2.583 + each: function( obj, callback, args ) { 2.584 + var name, 2.585 + i = 0, 2.586 + length = obj.length, 2.587 + isObj = length === undefined || jQuery.isFunction( obj ); 2.588 + 2.589 + if ( args ) { 2.590 + if ( isObj ) { 2.591 + for ( name in obj ) { 2.592 + if ( callback.apply( obj[ name ], args ) === false ) { 2.593 + break; 2.594 + } 2.595 + } 2.596 + } else { 2.597 + for ( ; i < length; ) { 2.598 + if ( callback.apply( obj[ i++ ], args ) === false ) { 2.599 + break; 2.600 + } 2.601 + } 2.602 + } 2.603 + 2.604 + // A special, fast, case for the most common use of each 2.605 + } else { 2.606 + if ( isObj ) { 2.607 + for ( name in obj ) { 2.608 + if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) { 2.609 + break; 2.610 + } 2.611 + } 2.612 + } else { 2.613 + for ( ; i < length; ) { 2.614 + if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) { 2.615 + break; 2.616 + } 2.617 + } 2.618 + } 2.619 + } 2.620 + 2.621 + return obj; 2.622 + }, 2.623 + 2.624 + // Use native String.trim function wherever possible 2.625 + trim: core_trim && !core_trim.call("\uFEFF\xA0") ? 2.626 + function( text ) { 2.627 + return text == null ? 2.628 + "" : 2.629 + core_trim.call( text ); 2.630 + } : 2.631 + 2.632 + // Otherwise use our own trimming functionality 2.633 + function( text ) { 2.634 + return text == null ? 2.635 + "" : 2.636 + ( text + "" ).replace( rtrim, "" ); 2.637 + }, 2.638 + 2.639 + // results is for internal usage only 2.640 + makeArray: function( arr, results ) { 2.641 + var type, 2.642 + ret = results || []; 2.643 + 2.644 + if ( arr != null ) { 2.645 + // The window, strings (and functions) also have 'length' 2.646 + // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 2.647 + type = jQuery.type( arr ); 2.648 + 2.649 + if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) { 2.650 + core_push.call( ret, arr ); 2.651 + } else { 2.652 + jQuery.merge( ret, arr ); 2.653 + } 2.654 + } 2.655 + 2.656 + return ret; 2.657 + }, 2.658 + 2.659 + inArray: function( elem, arr, i ) { 2.660 + var len; 2.661 + 2.662 + if ( arr ) { 2.663 + if ( core_indexOf ) { 2.664 + return core_indexOf.call( arr, elem, i ); 2.665 + } 2.666 + 2.667 + len = arr.length; 2.668 + i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; 2.669 + 2.670 + for ( ; i < len; i++ ) { 2.671 + // Skip accessing in sparse arrays 2.672 + if ( i in arr && arr[ i ] === elem ) { 2.673 + return i; 2.674 + } 2.675 + } 2.676 + } 2.677 + 2.678 + return -1; 2.679 + }, 2.680 + 2.681 + merge: function( first, second ) { 2.682 + var l = second.length, 2.683 + i = first.length, 2.684 + j = 0; 2.685 + 2.686 + if ( typeof l === "number" ) { 2.687 + for ( ; j < l; j++ ) { 2.688 + first[ i++ ] = second[ j ]; 2.689 + } 2.690 + 2.691 + } else { 2.692 + while ( second[j] !== undefined ) { 2.693 + first[ i++ ] = second[ j++ ]; 2.694 + } 2.695 + } 2.696 + 2.697 + first.length = i; 2.698 + 2.699 + return first; 2.700 + }, 2.701 + 2.702 + grep: function( elems, callback, inv ) { 2.703 + var retVal, 2.704 + ret = [], 2.705 + i = 0, 2.706 + length = elems.length; 2.707 + inv = !!inv; 2.708 + 2.709 + // Go through the array, only saving the items 2.710 + // that pass the validator function 2.711 + for ( ; i < length; i++ ) { 2.712 + retVal = !!callback( elems[ i ], i ); 2.713 + if ( inv !== retVal ) { 2.714 + ret.push( elems[ i ] ); 2.715 + } 2.716 + } 2.717 + 2.718 + return ret; 2.719 + }, 2.720 + 2.721 + // arg is for internal usage only 2.722 + map: function( elems, callback, arg ) { 2.723 + var value, key, 2.724 + ret = [], 2.725 + i = 0, 2.726 + length = elems.length, 2.727 + // jquery objects are treated as arrays 2.728 + isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ; 2.729 + 2.730 + // Go through the array, translating each of the items to their 2.731 + if ( isArray ) { 2.732 + for ( ; i < length; i++ ) { 2.733 + value = callback( elems[ i ], i, arg ); 2.734 + 2.735 + if ( value != null ) { 2.736 + ret[ ret.length ] = value; 2.737 + } 2.738 + } 2.739 + 2.740 + // Go through every key on the object, 2.741 + } else { 2.742 + for ( key in elems ) { 2.743 + value = callback( elems[ key ], key, arg ); 2.744 + 2.745 + if ( value != null ) { 2.746 + ret[ ret.length ] = value; 2.747 + } 2.748 + } 2.749 + } 2.750 + 2.751 + // Flatten any nested arrays 2.752 + return ret.concat.apply( [], ret ); 2.753 + }, 2.754 + 2.755 + // A global GUID counter for objects 2.756 + guid: 1, 2.757 + 2.758 + // Bind a function to a context, optionally partially applying any 2.759 + // arguments. 2.760 + proxy: function( fn, context ) { 2.761 + var tmp, args, proxy; 2.762 + 2.763 + if ( typeof context === "string" ) { 2.764 + tmp = fn[ context ]; 2.765 + context = fn; 2.766 + fn = tmp; 2.767 + } 2.768 + 2.769 + // Quick check to determine if target is callable, in the spec 2.770 + // this throws a TypeError, but we will just return undefined. 2.771 + if ( !jQuery.isFunction( fn ) ) { 2.772 + return undefined; 2.773 + } 2.774 + 2.775 + // Simulated bind 2.776 + args = core_slice.call( arguments, 2 ); 2.777 + proxy = function() { 2.778 + return fn.apply( context, args.concat( core_slice.call( arguments ) ) ); 2.779 + }; 2.780 + 2.781 + // Set the guid of unique handler to the same of original handler, so it can be removed 2.782 + proxy.guid = fn.guid = fn.guid || jQuery.guid++; 2.783 + 2.784 + return proxy; 2.785 + }, 2.786 + 2.787 + // Multifunctional method to get and set values of a collection 2.788 + // The value/s can optionally be executed if it's a function 2.789 + access: function( elems, fn, key, value, chainable, emptyGet, pass ) { 2.790 + var exec, 2.791 + bulk = key == null, 2.792 + i = 0, 2.793 + length = elems.length; 2.794 + 2.795 + // Sets many values 2.796 + if ( key && typeof key === "object" ) { 2.797 + for ( i in key ) { 2.798 + jQuery.access( elems, fn, i, key[i], 1, emptyGet, value ); 2.799 + } 2.800 + chainable = 1; 2.801 + 2.802 + // Sets one value 2.803 + } else if ( value !== undefined ) { 2.804 + // Optionally, function values get executed if exec is true 2.805 + exec = pass === undefined && jQuery.isFunction( value ); 2.806 + 2.807 + if ( bulk ) { 2.808 + // Bulk operations only iterate when executing function values 2.809 + if ( exec ) { 2.810 + exec = fn; 2.811 + fn = function( elem, key, value ) { 2.812 + return exec.call( jQuery( elem ), value ); 2.813 + }; 2.814 + 2.815 + // Otherwise they run against the entire set 2.816 + } else { 2.817 + fn.call( elems, value ); 2.818 + fn = null; 2.819 + } 2.820 + } 2.821 + 2.822 + if ( fn ) { 2.823 + for (; i < length; i++ ) { 2.824 + fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); 2.825 + } 2.826 + } 2.827 + 2.828 + chainable = 1; 2.829 + } 2.830 + 2.831 + return chainable ? 2.832 + elems : 2.833 + 2.834 + // Gets 2.835 + bulk ? 2.836 + fn.call( elems ) : 2.837 + length ? fn( elems[0], key ) : emptyGet; 2.838 + }, 2.839 + 2.840 + now: function() { 2.841 + return ( new Date() ).getTime(); 2.842 + } 2.843 +}); 2.844 + 2.845 +jQuery.ready.promise = function( obj ) { 2.846 + if ( !readyList ) { 2.847 + 2.848 + readyList = jQuery.Deferred(); 2.849 + 2.850 + // Catch cases where $(document).ready() is called after the browser event has already occurred. 2.851 + // we once tried to use readyState "interactive" here, but it caused issues like the one 2.852 + // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15 2.853 + if ( document.readyState === "complete" ) { 2.854 + // Handle it asynchronously to allow scripts the opportunity to delay ready 2.855 + setTimeout( jQuery.ready, 1 ); 2.856 + 2.857 + // Standards-based browsers support DOMContentLoaded 2.858 + } else if ( document.addEventListener ) { 2.859 + // Use the handy event callback 2.860 + document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 2.861 + 2.862 + // A fallback to window.onload, that will always work 2.863 + window.addEventListener( "load", jQuery.ready, false ); 2.864 + 2.865 + // If IE event model is used 2.866 + } else { 2.867 + // Ensure firing before onload, maybe late but safe also for iframes 2.868 + document.attachEvent( "onreadystatechange", DOMContentLoaded ); 2.869 + 2.870 + // A fallback to window.onload, that will always work 2.871 + window.attachEvent( "onload", jQuery.ready ); 2.872 + 2.873 + // If IE and not a frame 2.874 + // continually check to see if the document is ready 2.875 + var top = false; 2.876 + 2.877 + try { 2.878 + top = window.frameElement == null && document.documentElement; 2.879 + } catch(e) {} 2.880 + 2.881 + if ( top && top.doScroll ) { 2.882 + (function doScrollCheck() { 2.883 + if ( !jQuery.isReady ) { 2.884 + 2.885 + try { 2.886 + // Use the trick by Diego Perini 2.887 + // http://javascript.nwbox.com/IEContentLoaded/ 2.888 + top.doScroll("left"); 2.889 + } catch(e) { 2.890 + return setTimeout( doScrollCheck, 50 ); 2.891 + } 2.892 + 2.893 + // and execute any waiting functions 2.894 + jQuery.ready(); 2.895 + } 2.896 + })(); 2.897 + } 2.898 + } 2.899 + } 2.900 + return readyList.promise( obj ); 2.901 +}; 2.902 + 2.903 +// Populate the class2type map 2.904 +jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { 2.905 + class2type[ "[object " + name + "]" ] = name.toLowerCase(); 2.906 +}); 2.907 + 2.908 +// All jQuery objects should point back to these 2.909 +rootjQuery = jQuery(document); 2.910 +// String to Object options format cache 2.911 +var optionsCache = {}; 2.912 + 2.913 +// Convert String-formatted options into Object-formatted ones and store in cache 2.914 +function createOptions( options ) { 2.915 + var object = optionsCache[ options ] = {}; 2.916 + jQuery.each( options.split( core_rspace ), function( _, flag ) { 2.917 + object[ flag ] = true; 2.918 + }); 2.919 + return object; 2.920 +} 2.921 + 2.922 +/* 2.923 + * Create a callback list using the following parameters: 2.924 + * 2.925 + * options: an optional list of space-separated options that will change how 2.926 + * the callback list behaves or a more traditional option object 2.927 + * 2.928 + * By default a callback list will act like an event callback list and can be 2.929 + * "fired" multiple times. 2.930 + * 2.931 + * Possible options: 2.932 + * 2.933 + * once: will ensure the callback list can only be fired once (like a Deferred) 2.934 + * 2.935 + * memory: will keep track of previous values and will call any callback added 2.936 + * after the list has been fired right away with the latest "memorized" 2.937 + * values (like a Deferred) 2.938 + * 2.939 + * unique: will ensure a callback can only be added once (no duplicate in the list) 2.940 + * 2.941 + * stopOnFalse: interrupt callings when a callback returns false 2.942 + * 2.943 + */ 2.944 +jQuery.Callbacks = function( options ) { 2.945 + 2.946 + // Convert options from String-formatted to Object-formatted if needed 2.947 + // (we check in cache first) 2.948 + options = typeof options === "string" ? 2.949 + ( optionsCache[ options ] || createOptions( options ) ) : 2.950 + jQuery.extend( {}, options ); 2.951 + 2.952 + var // Last fire value (for non-forgettable lists) 2.953 + memory, 2.954 + // Flag to know if list was already fired 2.955 + fired, 2.956 + // Flag to know if list is currently firing 2.957 + firing, 2.958 + // First callback to fire (used internally by add and fireWith) 2.959 + firingStart, 2.960 + // End of the loop when firing 2.961 + firingLength, 2.962 + // Index of currently firing callback (modified by remove if needed) 2.963 + firingIndex, 2.964 + // Actual callback list 2.965 + list = [], 2.966 + // Stack of fire calls for repeatable lists 2.967 + stack = !options.once && [], 2.968 + // Fire callbacks 2.969 + fire = function( data ) { 2.970 + memory = options.memory && data; 2.971 + fired = true; 2.972 + firingIndex = firingStart || 0; 2.973 + firingStart = 0; 2.974 + firingLength = list.length; 2.975 + firing = true; 2.976 + for ( ; list && firingIndex < firingLength; firingIndex++ ) { 2.977 + if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) { 2.978 + memory = false; // To prevent further calls using add 2.979 + break; 2.980 + } 2.981 + } 2.982 + firing = false; 2.983 + if ( list ) { 2.984 + if ( stack ) { 2.985 + if ( stack.length ) { 2.986 + fire( stack.shift() ); 2.987 + } 2.988 + } else if ( memory ) { 2.989 + list = []; 2.990 + } else { 2.991 + self.disable(); 2.992 + } 2.993 + } 2.994 + }, 2.995 + // Actual Callbacks object 2.996 + self = { 2.997 + // Add a callback or a collection of callbacks to the list 2.998 + add: function() { 2.999 + if ( list ) { 2.1000 + // First, we save the current length 2.1001 + var start = list.length; 2.1002 + (function add( args ) { 2.1003 + jQuery.each( args, function( _, arg ) { 2.1004 + var type = jQuery.type( arg ); 2.1005 + if ( type === "function" && ( !options.unique || !self.has( arg ) ) ) { 2.1006 + list.push( arg ); 2.1007 + } else if ( arg && arg.length && type !== "string" ) { 2.1008 + // Inspect recursively 2.1009 + add( arg ); 2.1010 + } 2.1011 + }); 2.1012 + })( arguments ); 2.1013 + // Do we need to add the callbacks to the 2.1014 + // current firing batch? 2.1015 + if ( firing ) { 2.1016 + firingLength = list.length; 2.1017 + // With memory, if we're not firing then 2.1018 + // we should call right away 2.1019 + } else if ( memory ) { 2.1020 + firingStart = start; 2.1021 + fire( memory ); 2.1022 + } 2.1023 + } 2.1024 + return this; 2.1025 + }, 2.1026 + // Remove a callback from the list 2.1027 + remove: function() { 2.1028 + if ( list ) { 2.1029 + jQuery.each( arguments, function( _, arg ) { 2.1030 + var index; 2.1031 + while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { 2.1032 + list.splice( index, 1 ); 2.1033 + // Handle firing indexes 2.1034 + if ( firing ) { 2.1035 + if ( index <= firingLength ) { 2.1036 + firingLength--; 2.1037 + } 2.1038 + if ( index <= firingIndex ) { 2.1039 + firingIndex--; 2.1040 + } 2.1041 + } 2.1042 + } 2.1043 + }); 2.1044 + } 2.1045 + return this; 2.1046 + }, 2.1047 + // Control if a given callback is in the list 2.1048 + has: function( fn ) { 2.1049 + return jQuery.inArray( fn, list ) > -1; 2.1050 + }, 2.1051 + // Remove all callbacks from the list 2.1052 + empty: function() { 2.1053 + list = []; 2.1054 + return this; 2.1055 + }, 2.1056 + // Have the list do nothing anymore 2.1057 + disable: function() { 2.1058 + list = stack = memory = undefined; 2.1059 + return this; 2.1060 + }, 2.1061 + // Is it disabled? 2.1062 + disabled: function() { 2.1063 + return !list; 2.1064 + }, 2.1065 + // Lock the list in its current state 2.1066 + lock: function() { 2.1067 + stack = undefined; 2.1068 + if ( !memory ) { 2.1069 + self.disable(); 2.1070 + } 2.1071 + return this; 2.1072 + }, 2.1073 + // Is it locked? 2.1074 + locked: function() { 2.1075 + return !stack; 2.1076 + }, 2.1077 + // Call all callbacks with the given context and arguments 2.1078 + fireWith: function( context, args ) { 2.1079 + args = args || []; 2.1080 + args = [ context, args.slice ? args.slice() : args ]; 2.1081 + if ( list && ( !fired || stack ) ) { 2.1082 + if ( firing ) { 2.1083 + stack.push( args ); 2.1084 + } else { 2.1085 + fire( args ); 2.1086 + } 2.1087 + } 2.1088 + return this; 2.1089 + }, 2.1090 + // Call all the callbacks with the given arguments 2.1091 + fire: function() { 2.1092 + self.fireWith( this, arguments ); 2.1093 + return this; 2.1094 + }, 2.1095 + // To know if the callbacks have already been called at least once 2.1096 + fired: function() { 2.1097 + return !!fired; 2.1098 + } 2.1099 + }; 2.1100 + 2.1101 + return self; 2.1102 +}; 2.1103 +jQuery.extend({ 2.1104 + 2.1105 + Deferred: function( func ) { 2.1106 + var tuples = [ 2.1107 + // action, add listener, listener list, final state 2.1108 + [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ], 2.1109 + [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ], 2.1110 + [ "notify", "progress", jQuery.Callbacks("memory") ] 2.1111 + ], 2.1112 + state = "pending", 2.1113 + promise = { 2.1114 + state: function() { 2.1115 + return state; 2.1116 + }, 2.1117 + always: function() { 2.1118 + deferred.done( arguments ).fail( arguments ); 2.1119 + return this; 2.1120 + }, 2.1121 + then: function( /* fnDone, fnFail, fnProgress */ ) { 2.1122 + var fns = arguments; 2.1123 + return jQuery.Deferred(function( newDefer ) { 2.1124 + jQuery.each( tuples, function( i, tuple ) { 2.1125 + var action = tuple[ 0 ], 2.1126 + fn = fns[ i ]; 2.1127 + // deferred[ done | fail | progress ] for forwarding actions to newDefer 2.1128 + deferred[ tuple[1] ]( jQuery.isFunction( fn ) ? 2.1129 + function() { 2.1130 + var returned = fn.apply( this, arguments ); 2.1131 + if ( returned && jQuery.isFunction( returned.promise ) ) { 2.1132 + returned.promise() 2.1133 + .done( newDefer.resolve ) 2.1134 + .fail( newDefer.reject ) 2.1135 + .progress( newDefer.notify ); 2.1136 + } else { 2.1137 + newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); 2.1138 + } 2.1139 + } : 2.1140 + newDefer[ action ] 2.1141 + ); 2.1142 + }); 2.1143 + fns = null; 2.1144 + }).promise(); 2.1145 + }, 2.1146 + // Get a promise for this deferred 2.1147 + // If obj is provided, the promise aspect is added to the object 2.1148 + promise: function( obj ) { 2.1149 + return obj != null ? jQuery.extend( obj, promise ) : promise; 2.1150 + } 2.1151 + }, 2.1152 + deferred = {}; 2.1153 + 2.1154 + // Keep pipe for back-compat 2.1155 + promise.pipe = promise.then; 2.1156 + 2.1157 + // Add list-specific methods 2.1158 + jQuery.each( tuples, function( i, tuple ) { 2.1159 + var list = tuple[ 2 ], 2.1160 + stateString = tuple[ 3 ]; 2.1161 + 2.1162 + // promise[ done | fail | progress ] = list.add 2.1163 + promise[ tuple[1] ] = list.add; 2.1164 + 2.1165 + // Handle state 2.1166 + if ( stateString ) { 2.1167 + list.add(function() { 2.1168 + // state = [ resolved | rejected ] 2.1169 + state = stateString; 2.1170 + 2.1171 + // [ reject_list | resolve_list ].disable; progress_list.lock 2.1172 + }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock ); 2.1173 + } 2.1174 + 2.1175 + // deferred[ resolve | reject | notify ] = list.fire 2.1176 + deferred[ tuple[0] ] = list.fire; 2.1177 + deferred[ tuple[0] + "With" ] = list.fireWith; 2.1178 + }); 2.1179 + 2.1180 + // Make the deferred a promise 2.1181 + promise.promise( deferred ); 2.1182 + 2.1183 + // Call given func if any 2.1184 + if ( func ) { 2.1185 + func.call( deferred, deferred ); 2.1186 + } 2.1187 + 2.1188 + // All done! 2.1189 + return deferred; 2.1190 + }, 2.1191 + 2.1192 + // Deferred helper 2.1193 + when: function( subordinate /* , ..., subordinateN */ ) { 2.1194 + var i = 0, 2.1195 + resolveValues = core_slice.call( arguments ), 2.1196 + length = resolveValues.length, 2.1197 + 2.1198 + // the count of uncompleted subordinates 2.1199 + remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0, 2.1200 + 2.1201 + // the master Deferred. If resolveValues consist of only a single Deferred, just use that. 2.1202 + deferred = remaining === 1 ? subordinate : jQuery.Deferred(), 2.1203 + 2.1204 + // Update function for both resolve and progress values 2.1205 + updateFunc = function( i, contexts, values ) { 2.1206 + return function( value ) { 2.1207 + contexts[ i ] = this; 2.1208 + values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value; 2.1209 + if( values === progressValues ) { 2.1210 + deferred.notifyWith( contexts, values ); 2.1211 + } else if ( !( --remaining ) ) { 2.1212 + deferred.resolveWith( contexts, values ); 2.1213 + } 2.1214 + }; 2.1215 + }, 2.1216 + 2.1217 + progressValues, progressContexts, resolveContexts; 2.1218 + 2.1219 + // add listeners to Deferred subordinates; treat others as resolved 2.1220 + if ( length > 1 ) { 2.1221 + progressValues = new Array( length ); 2.1222 + progressContexts = new Array( length ); 2.1223 + resolveContexts = new Array( length ); 2.1224 + for ( ; i < length; i++ ) { 2.1225 + if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) { 2.1226 + resolveValues[ i ].promise() 2.1227 + .done( updateFunc( i, resolveContexts, resolveValues ) ) 2.1228 + .fail( deferred.reject ) 2.1229 + .progress( updateFunc( i, progressContexts, progressValues ) ); 2.1230 + } else { 2.1231 + --remaining; 2.1232 + } 2.1233 + } 2.1234 + } 2.1235 + 2.1236 + // if we're not waiting on anything, resolve the master 2.1237 + if ( !remaining ) { 2.1238 + deferred.resolveWith( resolveContexts, resolveValues ); 2.1239 + } 2.1240 + 2.1241 + return deferred.promise(); 2.1242 + } 2.1243 +}); 2.1244 +jQuery.support = (function() { 2.1245 + 2.1246 + var support, 2.1247 + all, 2.1248 + a, 2.1249 + select, 2.1250 + opt, 2.1251 + input, 2.1252 + fragment, 2.1253 + eventName, 2.1254 + i, 2.1255 + isSupported, 2.1256 + clickFn, 2.1257 + div = document.createElement("div"); 2.1258 + 2.1259 + // Preliminary tests 2.1260 + div.setAttribute( "className", "t" ); 2.1261 + div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; 2.1262 + 2.1263 + all = div.getElementsByTagName("*"); 2.1264 + a = div.getElementsByTagName("a")[ 0 ]; 2.1265 + a.style.cssText = "top:1px;float:left;opacity:.5"; 2.1266 + 2.1267 + // Can't get basic test support 2.1268 + if ( !all || !all.length ) { 2.1269 + return {}; 2.1270 + } 2.1271 + 2.1272 + // First batch of supports tests 2.1273 + select = document.createElement("select"); 2.1274 + opt = select.appendChild( document.createElement("option") ); 2.1275 + input = div.getElementsByTagName("input")[ 0 ]; 2.1276 + 2.1277 + support = { 2.1278 + // IE strips leading whitespace when .innerHTML is used 2.1279 + leadingWhitespace: ( div.firstChild.nodeType === 3 ), 2.1280 + 2.1281 + // Make sure that tbody elements aren't automatically inserted 2.1282 + // IE will insert them into empty tables 2.1283 + tbody: !div.getElementsByTagName("tbody").length, 2.1284 + 2.1285 + // Make sure that link elements get serialized correctly by innerHTML 2.1286 + // This requires a wrapper element in IE 2.1287 + htmlSerialize: !!div.getElementsByTagName("link").length, 2.1288 + 2.1289 + // Get the style information from getAttribute 2.1290 + // (IE uses .cssText instead) 2.1291 + style: /top/.test( a.getAttribute("style") ), 2.1292 + 2.1293 + // Make sure that URLs aren't manipulated 2.1294 + // (IE normalizes it by default) 2.1295 + hrefNormalized: ( a.getAttribute("href") === "/a" ), 2.1296 + 2.1297 + // Make sure that element opacity exists 2.1298 + // (IE uses filter instead) 2.1299 + // Use a regex to work around a WebKit issue. See #5145 2.1300 + opacity: /^0.5/.test( a.style.opacity ), 2.1301 + 2.1302 + // Verify style float existence 2.1303 + // (IE uses styleFloat instead of cssFloat) 2.1304 + cssFloat: !!a.style.cssFloat, 2.1305 + 2.1306 + // Make sure that if no value is specified for a checkbox 2.1307 + // that it defaults to "on". 2.1308 + // (WebKit defaults to "" instead) 2.1309 + checkOn: ( input.value === "on" ), 2.1310 + 2.1311 + // Make sure that a selected-by-default option has a working selected property. 2.1312 + // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) 2.1313 + optSelected: opt.selected, 2.1314 + 2.1315 + // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) 2.1316 + getSetAttribute: div.className !== "t", 2.1317 + 2.1318 + // Tests for enctype support on a form(#6743) 2.1319 + enctype: !!document.createElement("form").enctype, 2.1320 + 2.1321 + // Makes sure cloning an html5 element does not cause problems 2.1322 + // Where outerHTML is undefined, this still works 2.1323 + html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>", 2.1324 + 2.1325 + // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode 2.1326 + boxModel: ( document.compatMode === "CSS1Compat" ), 2.1327 + 2.1328 + // Will be defined later 2.1329 + submitBubbles: true, 2.1330 + changeBubbles: true, 2.1331 + focusinBubbles: false, 2.1332 + deleteExpando: true, 2.1333 + noCloneEvent: true, 2.1334 + inlineBlockNeedsLayout: false, 2.1335 + shrinkWrapBlocks: false, 2.1336 + reliableMarginRight: true, 2.1337 + boxSizingReliable: true, 2.1338 + pixelPosition: false 2.1339 + }; 2.1340 + 2.1341 + // Make sure checked status is properly cloned 2.1342 + input.checked = true; 2.1343 + support.noCloneChecked = input.cloneNode( true ).checked; 2.1344 + 2.1345 + // Make sure that the options inside disabled selects aren't marked as disabled 2.1346 + // (WebKit marks them as disabled) 2.1347 + select.disabled = true; 2.1348 + support.optDisabled = !opt.disabled; 2.1349 + 2.1350 + // Test to see if it's possible to delete an expando from an element 2.1351 + // Fails in Internet Explorer 2.1352 + try { 2.1353 + delete div.test; 2.1354 + } catch( e ) { 2.1355 + support.deleteExpando = false; 2.1356 + } 2.1357 + 2.1358 + if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { 2.1359 + div.attachEvent( "onclick", clickFn = function() { 2.1360 + // Cloning a node shouldn't copy over any 2.1361 + // bound event handlers (IE does this) 2.1362 + support.noCloneEvent = false; 2.1363 + }); 2.1364 + div.cloneNode( true ).fireEvent("onclick"); 2.1365 + div.detachEvent( "onclick", clickFn ); 2.1366 + } 2.1367 + 2.1368 + // Check if a radio maintains its value 2.1369 + // after being appended to the DOM 2.1370 + input = document.createElement("input"); 2.1371 + input.value = "t"; 2.1372 + input.setAttribute( "type", "radio" ); 2.1373 + support.radioValue = input.value === "t"; 2.1374 + 2.1375 + input.setAttribute( "checked", "checked" ); 2.1376 + 2.1377 + // #11217 - WebKit loses check when the name is after the checked attribute 2.1378 + input.setAttribute( "name", "t" ); 2.1379 + 2.1380 + div.appendChild( input ); 2.1381 + fragment = document.createDocumentFragment(); 2.1382 + fragment.appendChild( div.lastChild ); 2.1383 + 2.1384 + // WebKit doesn't clone checked state correctly in fragments 2.1385 + support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; 2.1386 + 2.1387 + // Check if a disconnected checkbox will retain its checked 2.1388 + // value of true after appended to the DOM (IE6/7) 2.1389 + support.appendChecked = input.checked; 2.1390 + 2.1391 + fragment.removeChild( input ); 2.1392 + fragment.appendChild( div ); 2.1393 + 2.1394 + // Technique from Juriy Zaytsev 2.1395 + // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/ 2.1396 + // We only care about the case where non-standard event systems 2.1397 + // are used, namely in IE. Short-circuiting here helps us to 2.1398 + // avoid an eval call (in setAttribute) which can cause CSP 2.1399 + // to go haywire. See: https://developer.mozilla.org/en/Security/CSP 2.1400 + if ( div.attachEvent ) { 2.1401 + for ( i in { 2.1402 + submit: true, 2.1403 + change: true, 2.1404 + focusin: true 2.1405 + }) { 2.1406 + eventName = "on" + i; 2.1407 + isSupported = ( eventName in div ); 2.1408 + if ( !isSupported ) { 2.1409 + div.setAttribute( eventName, "return;" ); 2.1410 + isSupported = ( typeof div[ eventName ] === "function" ); 2.1411 + } 2.1412 + support[ i + "Bubbles" ] = isSupported; 2.1413 + } 2.1414 + } 2.1415 + 2.1416 + // Run tests that need a body at doc ready 2.1417 + jQuery(function() { 2.1418 + var container, div, tds, marginDiv, 2.1419 + divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;", 2.1420 + body = document.getElementsByTagName("body")[0]; 2.1421 + 2.1422 + if ( !body ) { 2.1423 + // Return for frameset docs that don't have a body 2.1424 + return; 2.1425 + } 2.1426 + 2.1427 + container = document.createElement("div"); 2.1428 + container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px"; 2.1429 + body.insertBefore( container, body.firstChild ); 2.1430 + 2.1431 + // Construct the test element 2.1432 + div = document.createElement("div"); 2.1433 + container.appendChild( div ); 2.1434 + 2.1435 + // Check if table cells still have offsetWidth/Height when they are set 2.1436 + // to display:none and there are still other visible table cells in a 2.1437 + // table row; if so, offsetWidth/Height are not reliable for use when 2.1438 + // determining if an element has been hidden directly using 2.1439 + // display:none (it is still safe to use offsets if a parent element is 2.1440 + // hidden; don safety goggles and see bug #4512 for more information). 2.1441 + // (only IE 8 fails this test) 2.1442 + div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; 2.1443 + tds = div.getElementsByTagName("td"); 2.1444 + tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none"; 2.1445 + isSupported = ( tds[ 0 ].offsetHeight === 0 ); 2.1446 + 2.1447 + tds[ 0 ].style.display = ""; 2.1448 + tds[ 1 ].style.display = "none"; 2.1449 + 2.1450 + // Check if empty table cells still have offsetWidth/Height 2.1451 + // (IE <= 8 fail this test) 2.1452 + support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); 2.1453 + 2.1454 + // Check box-sizing and margin behavior 2.1455 + div.innerHTML = ""; 2.1456 + div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;"; 2.1457 + support.boxSizing = ( div.offsetWidth === 4 ); 2.1458 + support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 ); 2.1459 + 2.1460 + // NOTE: To any future maintainer, we've window.getComputedStyle 2.1461 + // because jsdom on node.js will break without it. 2.1462 + if ( window.getComputedStyle ) { 2.1463 + support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%"; 2.1464 + support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px"; 2.1465 + 2.1466 + // Check if div with explicit width and no margin-right incorrectly 2.1467 + // gets computed margin-right based on width of container. For more 2.1468 + // info see bug #3333 2.1469 + // Fails in WebKit before Feb 2011 nightlies 2.1470 + // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 2.1471 + marginDiv = document.createElement("div"); 2.1472 + marginDiv.style.cssText = div.style.cssText = divReset; 2.1473 + marginDiv.style.marginRight = marginDiv.style.width = "0"; 2.1474 + div.style.width = "1px"; 2.1475 + div.appendChild( marginDiv ); 2.1476 + support.reliableMarginRight = 2.1477 + !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight ); 2.1478 + } 2.1479 + 2.1480 + if ( typeof div.style.zoom !== "undefined" ) { 2.1481 + // Check if natively block-level elements act like inline-block 2.1482 + // elements when setting their display to 'inline' and giving 2.1483 + // them layout 2.1484 + // (IE < 8 does this) 2.1485 + div.innerHTML = ""; 2.1486 + div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1"; 2.1487 + support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 ); 2.1488 + 2.1489 + // Check if elements with layout shrink-wrap their children 2.1490 + // (IE 6 does this) 2.1491 + div.style.display = "block"; 2.1492 + div.style.overflow = "visible"; 2.1493 + div.innerHTML = "<div></div>"; 2.1494 + div.firstChild.style.width = "5px"; 2.1495 + support.shrinkWrapBlocks = ( div.offsetWidth !== 3 ); 2.1496 + 2.1497 + container.style.zoom = 1; 2.1498 + } 2.1499 + 2.1500 + // Null elements to avoid leaks in IE 2.1501 + body.removeChild( container ); 2.1502 + container = div = tds = marginDiv = null; 2.1503 + }); 2.1504 + 2.1505 + // Null elements to avoid leaks in IE 2.1506 + fragment.removeChild( div ); 2.1507 + all = a = select = opt = input = fragment = div = null; 2.1508 + 2.1509 + return support; 2.1510 +})(); 2.1511 +var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, 2.1512 + rmultiDash = /([A-Z])/g; 2.1513 + 2.1514 +jQuery.extend({ 2.1515 + cache: {}, 2.1516 + 2.1517 + deletedIds: [], 2.1518 + 2.1519 + // Remove at next major release (1.9/2.0) 2.1520 + uuid: 0, 2.1521 + 2.1522 + // Unique for each copy of jQuery on the page 2.1523 + // Non-digits removed to match rinlinejQuery 2.1524 + expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ), 2.1525 + 2.1526 + // The following elements throw uncatchable exceptions if you 2.1527 + // attempt to add expando properties to them. 2.1528 + noData: { 2.1529 + "embed": true, 2.1530 + // Ban all objects except for Flash (which handle expandos) 2.1531 + "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", 2.1532 + "applet": true 2.1533 + }, 2.1534 + 2.1535 + hasData: function( elem ) { 2.1536 + elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; 2.1537 + return !!elem && !isEmptyDataObject( elem ); 2.1538 + }, 2.1539 + 2.1540 + data: function( elem, name, data, pvt /* Internal Use Only */ ) { 2.1541 + if ( !jQuery.acceptData( elem ) ) { 2.1542 + return; 2.1543 + } 2.1544 + 2.1545 + var thisCache, ret, 2.1546 + internalKey = jQuery.expando, 2.1547 + getByName = typeof name === "string", 2.1548 + 2.1549 + // We have to handle DOM nodes and JS objects differently because IE6-7 2.1550 + // can't GC object references properly across the DOM-JS boundary 2.1551 + isNode = elem.nodeType, 2.1552 + 2.1553 + // Only DOM nodes need the global jQuery cache; JS object data is 2.1554 + // attached directly to the object so GC can occur automatically 2.1555 + cache = isNode ? jQuery.cache : elem, 2.1556 + 2.1557 + // Only defining an ID for JS objects if its cache already exists allows 2.1558 + // the code to shortcut on the same path as a DOM node with no cache 2.1559 + id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; 2.1560 + 2.1561 + // Avoid doing any more work than we need to when trying to get data on an 2.1562 + // object that has no data at all 2.1563 + if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { 2.1564 + return; 2.1565 + } 2.1566 + 2.1567 + if ( !id ) { 2.1568 + // Only DOM nodes need a new unique ID for each element since their data 2.1569 + // ends up in the global cache 2.1570 + if ( isNode ) { 2.1571 + elem[ internalKey ] = id = jQuery.deletedIds.pop() || jQuery.guid++; 2.1572 + } else { 2.1573 + id = internalKey; 2.1574 + } 2.1575 + } 2.1576 + 2.1577 + if ( !cache[ id ] ) { 2.1578 + cache[ id ] = {}; 2.1579 + 2.1580 + // Avoids exposing jQuery metadata on plain JS objects when the object 2.1581 + // is serialized using JSON.stringify 2.1582 + if ( !isNode ) { 2.1583 + cache[ id ].toJSON = jQuery.noop; 2.1584 + } 2.1585 + } 2.1586 + 2.1587 + // An object can be passed to jQuery.data instead of a key/value pair; this gets 2.1588 + // shallow copied over onto the existing cache 2.1589 + if ( typeof name === "object" || typeof name === "function" ) { 2.1590 + if ( pvt ) { 2.1591 + cache[ id ] = jQuery.extend( cache[ id ], name ); 2.1592 + } else { 2.1593 + cache[ id ].data = jQuery.extend( cache[ id ].data, name ); 2.1594 + } 2.1595 + } 2.1596 + 2.1597 + thisCache = cache[ id ]; 2.1598 + 2.1599 + // jQuery data() is stored in a separate object inside the object's internal data 2.1600 + // cache in order to avoid key collisions between internal data and user-defined 2.1601 + // data. 2.1602 + if ( !pvt ) { 2.1603 + if ( !thisCache.data ) { 2.1604 + thisCache.data = {}; 2.1605 + } 2.1606 + 2.1607 + thisCache = thisCache.data; 2.1608 + } 2.1609 + 2.1610 + if ( data !== undefined ) { 2.1611 + thisCache[ jQuery.camelCase( name ) ] = data; 2.1612 + } 2.1613 + 2.1614 + // Check for both converted-to-camel and non-converted data property names 2.1615 + // If a data property was specified 2.1616 + if ( getByName ) { 2.1617 + 2.1618 + // First Try to find as-is property data 2.1619 + ret = thisCache[ name ]; 2.1620 + 2.1621 + // Test for null|undefined property data 2.1622 + if ( ret == null ) { 2.1623 + 2.1624 + // Try to find the camelCased property 2.1625 + ret = thisCache[ jQuery.camelCase( name ) ]; 2.1626 + } 2.1627 + } else { 2.1628 + ret = thisCache; 2.1629 + } 2.1630 + 2.1631 + return ret; 2.1632 + }, 2.1633 + 2.1634 + removeData: function( elem, name, pvt /* Internal Use Only */ ) { 2.1635 + if ( !jQuery.acceptData( elem ) ) { 2.1636 + return; 2.1637 + } 2.1638 + 2.1639 + var thisCache, i, l, 2.1640 + 2.1641 + isNode = elem.nodeType, 2.1642 + 2.1643 + // See jQuery.data for more information 2.1644 + cache = isNode ? jQuery.cache : elem, 2.1645 + id = isNode ? elem[ jQuery.expando ] : jQuery.expando; 2.1646 + 2.1647 + // If there is already no cache entry for this object, there is no 2.1648 + // purpose in continuing 2.1649 + if ( !cache[ id ] ) { 2.1650 + return; 2.1651 + } 2.1652 + 2.1653 + if ( name ) { 2.1654 + 2.1655 + thisCache = pvt ? cache[ id ] : cache[ id ].data; 2.1656 + 2.1657 + if ( thisCache ) { 2.1658 + 2.1659 + // Support array or space separated string names for data keys 2.1660 + if ( !jQuery.isArray( name ) ) { 2.1661 + 2.1662 + // try the string as a key before any manipulation 2.1663 + if ( name in thisCache ) { 2.1664 + name = [ name ]; 2.1665 + } else { 2.1666 + 2.1667 + // split the camel cased version by spaces unless a key with the spaces exists 2.1668 + name = jQuery.camelCase( name ); 2.1669 + if ( name in thisCache ) { 2.1670 + name = [ name ]; 2.1671 + } else { 2.1672 + name = name.split(" "); 2.1673 + } 2.1674 + } 2.1675 + } 2.1676 + 2.1677 + for ( i = 0, l = name.length; i < l; i++ ) { 2.1678 + delete thisCache[ name[i] ]; 2.1679 + } 2.1680 + 2.1681 + // If there is no data left in the cache, we want to continue 2.1682 + // and let the cache object itself get destroyed 2.1683 + if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { 2.1684 + return; 2.1685 + } 2.1686 + } 2.1687 + } 2.1688 + 2.1689 + // See jQuery.data for more information 2.1690 + if ( !pvt ) { 2.1691 + delete cache[ id ].data; 2.1692 + 2.1693 + // Don't destroy the parent cache unless the internal data object 2.1694 + // had been the only thing left in it 2.1695 + if ( !isEmptyDataObject( cache[ id ] ) ) { 2.1696 + return; 2.1697 + } 2.1698 + } 2.1699 + 2.1700 + // Destroy the cache 2.1701 + if ( isNode ) { 2.1702 + jQuery.cleanData( [ elem ], true ); 2.1703 + 2.1704 + // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) 2.1705 + } else if ( jQuery.support.deleteExpando || cache != cache.window ) { 2.1706 + delete cache[ id ]; 2.1707 + 2.1708 + // When all else fails, null 2.1709 + } else { 2.1710 + cache[ id ] = null; 2.1711 + } 2.1712 + }, 2.1713 + 2.1714 + // For internal use only. 2.1715 + _data: function( elem, name, data ) { 2.1716 + return jQuery.data( elem, name, data, true ); 2.1717 + }, 2.1718 + 2.1719 + // A method for determining if a DOM node can handle the data expando 2.1720 + acceptData: function( elem ) { 2.1721 + var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ]; 2.1722 + 2.1723 + // nodes accept data unless otherwise specified; rejection can be conditional 2.1724 + return !noData || noData !== true && elem.getAttribute("classid") === noData; 2.1725 + } 2.1726 +}); 2.1727 + 2.1728 +jQuery.fn.extend({ 2.1729 + data: function( key, value ) { 2.1730 + var parts, part, attr, name, l, 2.1731 + elem = this[0], 2.1732 + i = 0, 2.1733 + data = null; 2.1734 + 2.1735 + // Gets all values 2.1736 + if ( key === undefined ) { 2.1737 + if ( this.length ) { 2.1738 + data = jQuery.data( elem ); 2.1739 + 2.1740 + if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { 2.1741 + attr = elem.attributes; 2.1742 + for ( l = attr.length; i < l; i++ ) { 2.1743 + name = attr[i].name; 2.1744 + 2.1745 + if ( !name.indexOf( "data-" ) ) { 2.1746 + name = jQuery.camelCase( name.substring(5) ); 2.1747 + 2.1748 + dataAttr( elem, name, data[ name ] ); 2.1749 + } 2.1750 + } 2.1751 + jQuery._data( elem, "parsedAttrs", true ); 2.1752 + } 2.1753 + } 2.1754 + 2.1755 + return data; 2.1756 + } 2.1757 + 2.1758 + // Sets multiple values 2.1759 + if ( typeof key === "object" ) { 2.1760 + return this.each(function() { 2.1761 + jQuery.data( this, key ); 2.1762 + }); 2.1763 + } 2.1764 + 2.1765 + parts = key.split( ".", 2 ); 2.1766 + parts[1] = parts[1] ? "." + parts[1] : ""; 2.1767 + part = parts[1] + "!"; 2.1768 + 2.1769 + return jQuery.access( this, function( value ) { 2.1770 + 2.1771 + if ( value === undefined ) { 2.1772 + data = this.triggerHandler( "getData" + part, [ parts[0] ] ); 2.1773 + 2.1774 + // Try to fetch any internally stored data first 2.1775 + if ( data === undefined && elem ) { 2.1776 + data = jQuery.data( elem, key ); 2.1777 + data = dataAttr( elem, key, data ); 2.1778 + } 2.1779 + 2.1780 + return data === undefined && parts[1] ? 2.1781 + this.data( parts[0] ) : 2.1782 + data; 2.1783 + } 2.1784 + 2.1785 + parts[1] = value; 2.1786 + this.each(function() { 2.1787 + var self = jQuery( this ); 2.1788 + 2.1789 + self.triggerHandler( "setData" + part, parts ); 2.1790 + jQuery.data( this, key, value ); 2.1791 + self.triggerHandler( "changeData" + part, parts ); 2.1792 + }); 2.1793 + }, null, value, arguments.length > 1, null, false ); 2.1794 + }, 2.1795 + 2.1796 + removeData: function( key ) { 2.1797 + return this.each(function() { 2.1798 + jQuery.removeData( this, key ); 2.1799 + }); 2.1800 + } 2.1801 +}); 2.1802 + 2.1803 +function dataAttr( elem, key, data ) { 2.1804 + // If nothing was found internally, try to fetch any 2.1805 + // data from the HTML5 data-* attribute 2.1806 + if ( data === undefined && elem.nodeType === 1 ) { 2.1807 + 2.1808 + var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); 2.1809 + 2.1810 + data = elem.getAttribute( name ); 2.1811 + 2.1812 + if ( typeof data === "string" ) { 2.1813 + try { 2.1814 + data = data === "true" ? true : 2.1815 + data === "false" ? false : 2.1816 + data === "null" ? null : 2.1817 + // Only convert to a number if it doesn't change the string 2.1818 + +data + "" === data ? +data : 2.1819 + rbrace.test( data ) ? jQuery.parseJSON( data ) : 2.1820 + data; 2.1821 + } catch( e ) {} 2.1822 + 2.1823 + // Make sure we set the data so it isn't changed later 2.1824 + jQuery.data( elem, key, data ); 2.1825 + 2.1826 + } else { 2.1827 + data = undefined; 2.1828 + } 2.1829 + } 2.1830 + 2.1831 + return data; 2.1832 +} 2.1833 + 2.1834 +// checks a cache object for emptiness 2.1835 +function isEmptyDataObject( obj ) { 2.1836 + var name; 2.1837 + for ( name in obj ) { 2.1838 + 2.1839 + // if the public data object is empty, the private is still empty 2.1840 + if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { 2.1841 + continue; 2.1842 + } 2.1843 + if ( name !== "toJSON" ) { 2.1844 + return false; 2.1845 + } 2.1846 + } 2.1847 + 2.1848 + return true; 2.1849 +} 2.1850 +jQuery.extend({ 2.1851 + queue: function( elem, type, data ) { 2.1852 + var queue; 2.1853 + 2.1854 + if ( elem ) { 2.1855 + type = ( type || "fx" ) + "queue"; 2.1856 + queue = jQuery._data( elem, type ); 2.1857 + 2.1858 + // Speed up dequeue by getting out quickly if this is just a lookup 2.1859 + if ( data ) { 2.1860 + if ( !queue || jQuery.isArray(data) ) { 2.1861 + queue = jQuery._data( elem, type, jQuery.makeArray(data) ); 2.1862 + } else { 2.1863 + queue.push( data ); 2.1864 + } 2.1865 + } 2.1866 + return queue || []; 2.1867 + } 2.1868 + }, 2.1869 + 2.1870 + dequeue: function( elem, type ) { 2.1871 + type = type || "fx"; 2.1872 + 2.1873 + var queue = jQuery.queue( elem, type ), 2.1874 + startLength = queue.length, 2.1875 + fn = queue.shift(), 2.1876 + hooks = jQuery._queueHooks( elem, type ), 2.1877 + next = function() { 2.1878 + jQuery.dequeue( elem, type ); 2.1879 + }; 2.1880 + 2.1881 + // If the fx queue is dequeued, always remove the progress sentinel 2.1882 + if ( fn === "inprogress" ) { 2.1883 + fn = queue.shift(); 2.1884 + startLength--; 2.1885 + } 2.1886 + 2.1887 + if ( fn ) { 2.1888 + 2.1889 + // Add a progress sentinel to prevent the fx queue from being 2.1890 + // automatically dequeued 2.1891 + if ( type === "fx" ) { 2.1892 + queue.unshift( "inprogress" ); 2.1893 + } 2.1894 + 2.1895 + // clear up the last queue stop function 2.1896 + delete hooks.stop; 2.1897 + fn.call( elem, next, hooks ); 2.1898 + } 2.1899 + 2.1900 + if ( !startLength && hooks ) { 2.1901 + hooks.empty.fire(); 2.1902 + } 2.1903 + }, 2.1904 + 2.1905 + // not intended for public consumption - generates a queueHooks object, or returns the current one 2.1906 + _queueHooks: function( elem, type ) { 2.1907 + var key = type + "queueHooks"; 2.1908 + return jQuery._data( elem, key ) || jQuery._data( elem, key, { 2.1909 + empty: jQuery.Callbacks("once memory").add(function() { 2.1910 + jQuery.removeData( elem, type + "queue", true ); 2.1911 + jQuery.removeData( elem, key, true ); 2.1912 + }) 2.1913 + }); 2.1914 + } 2.1915 +}); 2.1916 + 2.1917 +jQuery.fn.extend({ 2.1918 + queue: function( type, data ) { 2.1919 + var setter = 2; 2.1920 + 2.1921 + if ( typeof type !== "string" ) { 2.1922 + data = type; 2.1923 + type = "fx"; 2.1924 + setter--; 2.1925 + } 2.1926 + 2.1927 + if ( arguments.length < setter ) { 2.1928 + return jQuery.queue( this[0], type ); 2.1929 + } 2.1930 + 2.1931 + return data === undefined ? 2.1932 + this : 2.1933 + this.each(function() { 2.1934 + var queue = jQuery.queue( this, type, data ); 2.1935 + 2.1936 + // ensure a hooks for this queue 2.1937 + jQuery._queueHooks( this, type ); 2.1938 + 2.1939 + if ( type === "fx" && queue[0] !== "inprogress" ) { 2.1940 + jQuery.dequeue( this, type ); 2.1941 + } 2.1942 + }); 2.1943 + }, 2.1944 + dequeue: function( type ) { 2.1945 + return this.each(function() { 2.1946 + jQuery.dequeue( this, type ); 2.1947 + }); 2.1948 + }, 2.1949 + // Based off of the plugin by Clint Helfers, with permission. 2.1950 + // http://blindsignals.com/index.php/2009/07/jquery-delay/ 2.1951 + delay: function( time, type ) { 2.1952 + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 2.1953 + type = type || "fx"; 2.1954 + 2.1955 + return this.queue( type, function( next, hooks ) { 2.1956 + var timeout = setTimeout( next, time ); 2.1957 + hooks.stop = function() { 2.1958 + clearTimeout( timeout ); 2.1959 + }; 2.1960 + }); 2.1961 + }, 2.1962 + clearQueue: function( type ) { 2.1963 + return this.queue( type || "fx", [] ); 2.1964 + }, 2.1965 + // Get a promise resolved when queues of a certain type 2.1966 + // are emptied (fx is the type by default) 2.1967 + promise: function( type, obj ) { 2.1968 + var tmp, 2.1969 + count = 1, 2.1970 + defer = jQuery.Deferred(), 2.1971 + elements = this, 2.1972 + i = this.length, 2.1973 + resolve = function() { 2.1974 + if ( !( --count ) ) { 2.1975 + defer.resolveWith( elements, [ elements ] ); 2.1976 + } 2.1977 + }; 2.1978 + 2.1979 + if ( typeof type !== "string" ) { 2.1980 + obj = type; 2.1981 + type = undefined; 2.1982 + } 2.1983 + type = type || "fx"; 2.1984 + 2.1985 + while( i-- ) { 2.1986 + tmp = jQuery._data( elements[ i ], type + "queueHooks" ); 2.1987 + if ( tmp && tmp.empty ) { 2.1988 + count++; 2.1989 + tmp.empty.add( resolve ); 2.1990 + } 2.1991 + } 2.1992 + resolve(); 2.1993 + return defer.promise( obj ); 2.1994 + } 2.1995 +}); 2.1996 +var nodeHook, boolHook, fixSpecified, 2.1997 + rclass = /[\t\r\n]/g, 2.1998 + rreturn = /\r/g, 2.1999 + rtype = /^(?:button|input)$/i, 2.2000 + rfocusable = /^(?:button|input|object|select|textarea)$/i, 2.2001 + rclickable = /^a(?:rea|)$/i, 2.2002 + rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, 2.2003 + getSetAttribute = jQuery.support.getSetAttribute; 2.2004 + 2.2005 +jQuery.fn.extend({ 2.2006 + attr: function( name, value ) { 2.2007 + return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 ); 2.2008 + }, 2.2009 + 2.2010 + removeAttr: function( name ) { 2.2011 + return this.each(function() { 2.2012 + jQuery.removeAttr( this, name ); 2.2013 + }); 2.2014 + }, 2.2015 + 2.2016 + prop: function( name, value ) { 2.2017 + return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 ); 2.2018 + }, 2.2019 + 2.2020 + removeProp: function( name ) { 2.2021 + name = jQuery.propFix[ name ] || name; 2.2022 + return this.each(function() { 2.2023 + // try/catch handles cases where IE balks (such as removing a property on window) 2.2024 + try { 2.2025 + this[ name ] = undefined; 2.2026 + delete this[ name ]; 2.2027 + } catch( e ) {} 2.2028 + }); 2.2029 + }, 2.2030 + 2.2031 + addClass: function( value ) { 2.2032 + var classNames, i, l, elem, 2.2033 + setClass, c, cl; 2.2034 + 2.2035 + if ( jQuery.isFunction( value ) ) { 2.2036 + return this.each(function( j ) { 2.2037 + jQuery( this ).addClass( value.call(this, j, this.className) ); 2.2038 + }); 2.2039 + } 2.2040 + 2.2041 + if ( value && typeof value === "string" ) { 2.2042 + classNames = value.split( core_rspace ); 2.2043 + 2.2044 + for ( i = 0, l = this.length; i < l; i++ ) { 2.2045 + elem = this[ i ]; 2.2046 + 2.2047 + if ( elem.nodeType === 1 ) { 2.2048 + if ( !elem.className && classNames.length === 1 ) { 2.2049 + elem.className = value; 2.2050 + 2.2051 + } else { 2.2052 + setClass = " " + elem.className + " "; 2.2053 + 2.2054 + for ( c = 0, cl = classNames.length; c < cl; c++ ) { 2.2055 + if ( setClass.indexOf( " " + classNames[ c ] + " " ) < 0 ) { 2.2056 + setClass += classNames[ c ] + " "; 2.2057 + } 2.2058 + } 2.2059 + elem.className = jQuery.trim( setClass ); 2.2060 + } 2.2061 + } 2.2062 + } 2.2063 + } 2.2064 + 2.2065 + return this; 2.2066 + }, 2.2067 + 2.2068 + removeClass: function( value ) { 2.2069 + var removes, className, elem, c, cl, i, l; 2.2070 + 2.2071 + if ( jQuery.isFunction( value ) ) { 2.2072 + return this.each(function( j ) { 2.2073 + jQuery( this ).removeClass( value.call(this, j, this.className) ); 2.2074 + }); 2.2075 + } 2.2076 + if ( (value && typeof value === "string") || value === undefined ) { 2.2077 + removes = ( value || "" ).split( core_rspace ); 2.2078 + 2.2079 + for ( i = 0, l = this.length; i < l; i++ ) { 2.2080 + elem = this[ i ]; 2.2081 + if ( elem.nodeType === 1 && elem.className ) { 2.2082 + 2.2083 + className = (" " + elem.className + " ").replace( rclass, " " ); 2.2084 + 2.2085 + // loop over each item in the removal list 2.2086 + for ( c = 0, cl = removes.length; c < cl; c++ ) { 2.2087 + // Remove until there is nothing to remove, 2.2088 + while ( className.indexOf(" " + removes[ c ] + " ") >= 0 ) { 2.2089 + className = className.replace( " " + removes[ c ] + " " , " " ); 2.2090 + } 2.2091 + } 2.2092 + elem.className = value ? jQuery.trim( className ) : ""; 2.2093 + } 2.2094 + } 2.2095 + } 2.2096 + 2.2097 + return this; 2.2098 + }, 2.2099 + 2.2100 + toggleClass: function( value, stateVal ) { 2.2101 + var type = typeof value, 2.2102 + isBool = typeof stateVal === "boolean"; 2.2103 + 2.2104 + if ( jQuery.isFunction( value ) ) { 2.2105 + return this.each(function( i ) { 2.2106 + jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); 2.2107 + }); 2.2108 + } 2.2109 + 2.2110 + return this.each(function() { 2.2111 + if ( type === "string" ) { 2.2112 + // toggle individual class names 2.2113 + var className, 2.2114 + i = 0, 2.2115 + self = jQuery( this ), 2.2116 + state = stateVal, 2.2117 + classNames = value.split( core_rspace ); 2.2118 + 2.2119 + while ( (className = classNames[ i++ ]) ) { 2.2120 + // check each className given, space separated list 2.2121 + state = isBool ? state : !self.hasClass( className ); 2.2122 + self[ state ? "addClass" : "removeClass" ]( className ); 2.2123 + } 2.2124 + 2.2125 + } else if ( type === "undefined" || type === "boolean" ) { 2.2126 + if ( this.className ) { 2.2127 + // store className if set 2.2128 + jQuery._data( this, "__className__", this.className ); 2.2129 + } 2.2130 + 2.2131 + // toggle whole className 2.2132 + this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || ""; 2.2133 + } 2.2134 + }); 2.2135 + }, 2.2136 + 2.2137 + hasClass: function( selector ) { 2.2138 + var className = " " + selector + " ", 2.2139 + i = 0, 2.2140 + l = this.length; 2.2141 + for ( ; i < l; i++ ) { 2.2142 + if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) { 2.2143 + return true; 2.2144 + } 2.2145 + } 2.2146 + 2.2147 + return false; 2.2148 + }, 2.2149 + 2.2150 + val: function( value ) { 2.2151 + var hooks, ret, isFunction, 2.2152 + elem = this[0]; 2.2153 + 2.2154 + if ( !arguments.length ) { 2.2155 + if ( elem ) { 2.2156 + hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; 2.2157 + 2.2158 + if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { 2.2159 + return ret; 2.2160 + } 2.2161 + 2.2162 + ret = elem.value; 2.2163 + 2.2164 + return typeof ret === "string" ? 2.2165 + // handle most common string cases 2.2166 + ret.replace(rreturn, "") : 2.2167 + // handle cases where value is null/undef or number 2.2168 + ret == null ? "" : ret; 2.2169 + } 2.2170 + 2.2171 + return; 2.2172 + } 2.2173 + 2.2174 + isFunction = jQuery.isFunction( value ); 2.2175 + 2.2176 + return this.each(function( i ) { 2.2177 + var val, 2.2178 + self = jQuery(this); 2.2179 + 2.2180 + if ( this.nodeType !== 1 ) { 2.2181 + return; 2.2182 + } 2.2183 + 2.2184 + if ( isFunction ) { 2.2185 + val = value.call( this, i, self.val() ); 2.2186 + } else { 2.2187 + val = value; 2.2188 + } 2.2189 + 2.2190 + // Treat null/undefined as ""; convert numbers to string 2.2191 + if ( val == null ) { 2.2192 + val = ""; 2.2193 + } else if ( typeof val === "number" ) { 2.2194 + val += ""; 2.2195 + } else if ( jQuery.isArray( val ) ) { 2.2196 + val = jQuery.map(val, function ( value ) { 2.2197 + return value == null ? "" : value + ""; 2.2198 + }); 2.2199 + } 2.2200 + 2.2201 + hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; 2.2202 + 2.2203 + // If set returns undefined, fall back to normal setting 2.2204 + if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { 2.2205 + this.value = val; 2.2206 + } 2.2207 + }); 2.2208 + } 2.2209 +}); 2.2210 + 2.2211 +jQuery.extend({ 2.2212 + valHooks: { 2.2213 + option: { 2.2214 + get: function( elem ) { 2.2215 + // attributes.value is undefined in Blackberry 4.7 but 2.2216 + // uses .value. See #6932 2.2217 + var val = elem.attributes.value; 2.2218 + return !val || val.specified ? elem.value : elem.text; 2.2219 + } 2.2220 + }, 2.2221 + select: { 2.2222 + get: function( elem ) { 2.2223 + var value, i, max, option, 2.2224 + index = elem.selectedIndex, 2.2225 + values = [], 2.2226 + options = elem.options, 2.2227 + one = elem.type === "select-one"; 2.2228 + 2.2229 + // Nothing was selected 2.2230 + if ( index < 0 ) { 2.2231 + return null; 2.2232 + } 2.2233 + 2.2234 + // Loop through all the selected options 2.2235 + i = one ? index : 0; 2.2236 + max = one ? index + 1 : options.length; 2.2237 + for ( ; i < max; i++ ) { 2.2238 + option = options[ i ]; 2.2239 + 2.2240 + // Don't return options that are disabled or in a disabled optgroup 2.2241 + if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && 2.2242 + (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) { 2.2243 + 2.2244 + // Get the specific value for the option 2.2245 + value = jQuery( option ).val(); 2.2246 + 2.2247 + // We don't need an array for one selects 2.2248 + if ( one ) { 2.2249 + return value; 2.2250 + } 2.2251 + 2.2252 + // Multi-Selects return an array 2.2253 + values.push( value ); 2.2254 + } 2.2255 + } 2.2256 + 2.2257 + // Fixes Bug #2551 -- select.val() broken in IE after form.reset() 2.2258 + if ( one && !values.length && options.length ) { 2.2259 + return jQuery( options[ index ] ).val(); 2.2260 + } 2.2261 + 2.2262 + return values; 2.2263 + }, 2.2264 + 2.2265 + set: function( elem, value ) { 2.2266 + var values = jQuery.makeArray( value ); 2.2267 + 2.2268 + jQuery(elem).find("option").each(function() { 2.2269 + this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0; 2.2270 + }); 2.2271 + 2.2272 + if ( !values.length ) { 2.2273 + elem.selectedIndex = -1; 2.2274 + } 2.2275 + return values; 2.2276 + } 2.2277 + } 2.2278 + }, 2.2279 + 2.2280 + // Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9 2.2281 + attrFn: {}, 2.2282 + 2.2283 + attr: function( elem, name, value, pass ) { 2.2284 + var ret, hooks, notxml, 2.2285 + nType = elem.nodeType; 2.2286 + 2.2287 + // don't get/set attributes on text, comment and attribute nodes 2.2288 + if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { 2.2289 + return; 2.2290 + } 2.2291 + 2.2292 + if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) { 2.2293 + return jQuery( elem )[ name ]( value ); 2.2294 + } 2.2295 + 2.2296 + // Fallback to prop when attributes are not supported 2.2297 + if ( typeof elem.getAttribute === "undefined" ) { 2.2298 + return jQuery.prop( elem, name, value ); 2.2299 + } 2.2300 + 2.2301 + notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 2.2302 + 2.2303 + // All attributes are lowercase 2.2304 + // Grab necessary hook if one is defined 2.2305 + if ( notxml ) { 2.2306 + name = name.toLowerCase(); 2.2307 + hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); 2.2308 + } 2.2309 + 2.2310 + if ( value !== undefined ) { 2.2311 + 2.2312 + if ( value === null ) { 2.2313 + jQuery.removeAttr( elem, name ); 2.2314 + return; 2.2315 + 2.2316 + } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { 2.2317 + return ret; 2.2318 + 2.2319 + } else { 2.2320 + elem.setAttribute( name, value + "" ); 2.2321 + return value; 2.2322 + } 2.2323 + 2.2324 + } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) { 2.2325 + return ret; 2.2326 + 2.2327 + } else { 2.2328 + 2.2329 + ret = elem.getAttribute( name ); 2.2330 + 2.2331 + // Non-existent attributes return null, we normalize to undefined 2.2332 + return ret === null ? 2.2333 + undefined : 2.2334 + ret; 2.2335 + } 2.2336 + }, 2.2337 + 2.2338 + removeAttr: function( elem, value ) { 2.2339 + var propName, attrNames, name, isBool, 2.2340 + i = 0; 2.2341 + 2.2342 + if ( value && elem.nodeType === 1 ) { 2.2343 + 2.2344 + attrNames = value.split( core_rspace ); 2.2345 + 2.2346 + for ( ; i < attrNames.length; i++ ) { 2.2347 + name = attrNames[ i ]; 2.2348 + 2.2349 + if ( name ) { 2.2350 + propName = jQuery.propFix[ name ] || name; 2.2351 + isBool = rboolean.test( name ); 2.2352 + 2.2353 + // See #9699 for explanation of this approach (setting first, then removal) 2.2354 + // Do not do this for boolean attributes (see #10870) 2.2355 + if ( !isBool ) { 2.2356 + jQuery.attr( elem, name, "" ); 2.2357 + } 2.2358 + elem.removeAttribute( getSetAttribute ? name : propName ); 2.2359 + 2.2360 + // Set corresponding property to false for boolean attributes 2.2361 + if ( isBool && propName in elem ) { 2.2362 + elem[ propName ] = false; 2.2363 + } 2.2364 + } 2.2365 + } 2.2366 + } 2.2367 + }, 2.2368 + 2.2369 + attrHooks: { 2.2370 + type: { 2.2371 + set: function( elem, value ) { 2.2372 + // We can't allow the type property to be changed (since it causes problems in IE) 2.2373 + if ( rtype.test( elem.nodeName ) && elem.parentNode ) { 2.2374 + jQuery.error( "type property can't be changed" ); 2.2375 + } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { 2.2376 + // Setting the type on a radio button after the value resets the value in IE6-9 2.2377 + // Reset value to it's default in case type is set after value 2.2378 + // This is for element creation 2.2379 + var val = elem.value; 2.2380 + elem.setAttribute( "type", value ); 2.2381 + if ( val ) { 2.2382 + elem.value = val; 2.2383 + } 2.2384 + return value; 2.2385 + } 2.2386 + } 2.2387 + }, 2.2388 + // Use the value property for back compat 2.2389 + // Use the nodeHook for button elements in IE6/7 (#1954) 2.2390 + value: { 2.2391 + get: function( elem, name ) { 2.2392 + if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { 2.2393 + return nodeHook.get( elem, name ); 2.2394 + } 2.2395 + return name in elem ? 2.2396 + elem.value : 2.2397 + null; 2.2398 + }, 2.2399 + set: function( elem, value, name ) { 2.2400 + if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { 2.2401 + return nodeHook.set( elem, value, name ); 2.2402 + } 2.2403 + // Does not return so that setAttribute is also used 2.2404 + elem.value = value; 2.2405 + } 2.2406 + } 2.2407 + }, 2.2408 + 2.2409 + propFix: { 2.2410 + tabindex: "tabIndex", 2.2411 + readonly: "readOnly", 2.2412 + "for": "htmlFor", 2.2413 + "class": "className", 2.2414 + maxlength: "maxLength", 2.2415 + cellspacing: "cellSpacing", 2.2416 + cellpadding: "cellPadding", 2.2417 + rowspan: "rowSpan", 2.2418 + colspan: "colSpan", 2.2419 + usemap: "useMap", 2.2420 + frameborder: "frameBorder", 2.2421 + contenteditable: "contentEditable" 2.2422 + }, 2.2423 + 2.2424 + prop: function( elem, name, value ) { 2.2425 + var ret, hooks, notxml, 2.2426 + nType = elem.nodeType; 2.2427 + 2.2428 + // don't get/set properties on text, comment and attribute nodes 2.2429 + if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { 2.2430 + return; 2.2431 + } 2.2432 + 2.2433 + notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 2.2434 + 2.2435 + if ( notxml ) { 2.2436 + // Fix name and attach hooks 2.2437 + name = jQuery.propFix[ name ] || name; 2.2438 + hooks = jQuery.propHooks[ name ]; 2.2439 + } 2.2440 + 2.2441 + if ( value !== undefined ) { 2.2442 + if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { 2.2443 + return ret; 2.2444 + 2.2445 + } else { 2.2446 + return ( elem[ name ] = value ); 2.2447 + } 2.2448 + 2.2449 + } else { 2.2450 + if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { 2.2451 + return ret; 2.2452 + 2.2453 + } else { 2.2454 + return elem[ name ]; 2.2455 + } 2.2456 + } 2.2457 + }, 2.2458 + 2.2459 + propHooks: { 2.2460 + tabIndex: { 2.2461 + get: function( elem ) { 2.2462 + // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set 2.2463 + // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 2.2464 + var attributeNode = elem.getAttributeNode("tabindex"); 2.2465 + 2.2466 + return attributeNode && attributeNode.specified ? 2.2467 + parseInt( attributeNode.value, 10 ) : 2.2468 + rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 2.2469 + 0 : 2.2470 + undefined; 2.2471 + } 2.2472 + } 2.2473 + } 2.2474 +}); 2.2475 + 2.2476 +// Hook for boolean attributes 2.2477 +boolHook = { 2.2478 + get: function( elem, name ) { 2.2479 + // Align boolean attributes with corresponding properties 2.2480 + // Fall back to attribute presence where some booleans are not supported 2.2481 + var attrNode, 2.2482 + property = jQuery.prop( elem, name ); 2.2483 + return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? 2.2484 + name.toLowerCase() : 2.2485 + undefined; 2.2486 + }, 2.2487 + set: function( elem, value, name ) { 2.2488 + var propName; 2.2489 + if ( value === false ) { 2.2490 + // Remove boolean attributes when set to false 2.2491 + jQuery.removeAttr( elem, name ); 2.2492 + } else { 2.2493 + // value is true since we know at this point it's type boolean and not false 2.2494 + // Set boolean attributes to the same name and set the DOM property 2.2495 + propName = jQuery.propFix[ name ] || name; 2.2496 + if ( propName in elem ) { 2.2497 + // Only set the IDL specifically if it already exists on the element 2.2498 + elem[ propName ] = true; 2.2499 + } 2.2500 + 2.2501 + elem.setAttribute( name, name.toLowerCase() ); 2.2502 + } 2.2503 + return name; 2.2504 + } 2.2505 +}; 2.2506 + 2.2507 +// IE6/7 do not support getting/setting some attributes with get/setAttribute 2.2508 +if ( !getSetAttribute ) { 2.2509 + 2.2510 + fixSpecified = { 2.2511 + name: true, 2.2512 + id: true, 2.2513 + coords: true 2.2514 + }; 2.2515 + 2.2516 + // Use this for any attribute in IE6/7 2.2517 + // This fixes almost every IE6/7 issue 2.2518 + nodeHook = jQuery.valHooks.button = { 2.2519 + get: function( elem, name ) { 2.2520 + var ret; 2.2521 + ret = elem.getAttributeNode( name ); 2.2522 + return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ? 2.2523 + ret.value : 2.2524 + undefined; 2.2525 + }, 2.2526 + set: function( elem, value, name ) { 2.2527 + // Set the existing or create a new attribute node 2.2528 + var ret = elem.getAttributeNode( name ); 2.2529 + if ( !ret ) { 2.2530 + ret = document.createAttribute( name ); 2.2531 + elem.setAttributeNode( ret ); 2.2532 + } 2.2533 + return ( ret.value = value + "" ); 2.2534 + } 2.2535 + }; 2.2536 + 2.2537 + // Set width and height to auto instead of 0 on empty string( Bug #8150 ) 2.2538 + // This is for removals 2.2539 + jQuery.each([ "width", "height" ], function( i, name ) { 2.2540 + jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { 2.2541 + set: function( elem, value ) { 2.2542 + if ( value === "" ) { 2.2543 + elem.setAttribute( name, "auto" ); 2.2544 + return value; 2.2545 + } 2.2546 + } 2.2547 + }); 2.2548 + }); 2.2549 + 2.2550 + // Set contenteditable to false on removals(#10429) 2.2551 + // Setting to empty string throws an error as an invalid value 2.2552 + jQuery.attrHooks.contenteditable = { 2.2553 + get: nodeHook.get, 2.2554 + set: function( elem, value, name ) { 2.2555 + if ( value === "" ) { 2.2556 + value = "false"; 2.2557 + } 2.2558 + nodeHook.set( elem, value, name ); 2.2559 + } 2.2560 + }; 2.2561 +} 2.2562 + 2.2563 + 2.2564 +// Some attributes require a special call on IE 2.2565 +if ( !jQuery.support.hrefNormalized ) { 2.2566 + jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { 2.2567 + jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { 2.2568 + get: function( elem ) { 2.2569 + var ret = elem.getAttribute( name, 2 ); 2.2570 + return ret === null ? undefined : ret; 2.2571 + } 2.2572 + }); 2.2573 + }); 2.2574 +} 2.2575 + 2.2576 +if ( !jQuery.support.style ) { 2.2577 + jQuery.attrHooks.style = { 2.2578 + get: function( elem ) { 2.2579 + // Return undefined in the case of empty string 2.2580 + // Normalize to lowercase since IE uppercases css property names 2.2581 + return elem.style.cssText.toLowerCase() || undefined; 2.2582 + }, 2.2583 + set: function( elem, value ) { 2.2584 + return ( elem.style.cssText = value + "" ); 2.2585 + } 2.2586 + }; 2.2587 +} 2.2588 + 2.2589 +// Safari mis-reports the default selected property of an option 2.2590 +// Accessing the parent's selectedIndex property fixes it 2.2591 +if ( !jQuery.support.optSelected ) { 2.2592 + jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, { 2.2593 + get: function( elem ) { 2.2594 + var parent = elem.parentNode; 2.2595 + 2.2596 + if ( parent ) { 2.2597 + parent.selectedIndex; 2.2598 + 2.2599 + // Make sure that it also works with optgroups, see #5701 2.2600 + if ( parent.parentNode ) { 2.2601 + parent.parentNode.selectedIndex; 2.2602 + } 2.2603 + } 2.2604 + return null; 2.2605 + } 2.2606 + }); 2.2607 +} 2.2608 + 2.2609 +// IE6/7 call enctype encoding 2.2610 +if ( !jQuery.support.enctype ) { 2.2611 + jQuery.propFix.enctype = "encoding"; 2.2612 +} 2.2613 + 2.2614 +// Radios and checkboxes getter/setter 2.2615 +if ( !jQuery.support.checkOn ) { 2.2616 + jQuery.each([ "radio", "checkbox" ], function() { 2.2617 + jQuery.valHooks[ this ] = { 2.2618 + get: function( elem ) { 2.2619 + // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified 2.2620 + return elem.getAttribute("value") === null ? "on" : elem.value; 2.2621 + } 2.2622 + }; 2.2623 + }); 2.2624 +} 2.2625 +jQuery.each([ "radio", "checkbox" ], function() { 2.2626 + jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], { 2.2627 + set: function( elem, value ) { 2.2628 + if ( jQuery.isArray( value ) ) { 2.2629 + return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 ); 2.2630 + } 2.2631 + } 2.2632 + }); 2.2633 +}); 2.2634 +var rformElems = /^(?:textarea|input|select)$/i, 2.2635 + rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/, 2.2636 + rhoverHack = /(?:^|\s)hover(\.\S+|)\b/, 2.2637 + rkeyEvent = /^key/, 2.2638 + rmouseEvent = /^(?:mouse|contextmenu)|click/, 2.2639 + rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 2.2640 + hoverHack = function( events ) { 2.2641 + return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); 2.2642 + }; 2.2643 + 2.2644 +/* 2.2645 + * Helper functions for managing events -- not part of the public interface. 2.2646 + * Props to Dean Edwards' addEvent library for many of the ideas. 2.2647 + */ 2.2648 +jQuery.event = { 2.2649 + 2.2650 + add: function( elem, types, handler, data, selector ) { 2.2651 + 2.2652 + var elemData, eventHandle, events, 2.2653 + t, tns, type, namespaces, handleObj, 2.2654 + handleObjIn, handlers, special; 2.2655 + 2.2656 + // Don't attach events to noData or text/comment nodes (allow plain objects tho) 2.2657 + if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) { 2.2658 + return; 2.2659 + } 2.2660 + 2.2661 + // Caller can pass in an object of custom data in lieu of the handler 2.2662 + if ( handler.handler ) { 2.2663 + handleObjIn = handler; 2.2664 + handler = handleObjIn.handler; 2.2665 + selector = handleObjIn.selector; 2.2666 + } 2.2667 + 2.2668 + // Make sure that the handler has a unique ID, used to find/remove it later 2.2669 + if ( !handler.guid ) { 2.2670 + handler.guid = jQuery.guid++; 2.2671 + } 2.2672 + 2.2673 + // Init the element's event structure and main handler, if this is the first 2.2674 + events = elemData.events; 2.2675 + if ( !events ) { 2.2676 + elemData.events = events = {}; 2.2677 + } 2.2678 + eventHandle = elemData.handle; 2.2679 + if ( !eventHandle ) { 2.2680 + elemData.handle = eventHandle = function( e ) { 2.2681 + // Discard the second event of a jQuery.event.trigger() and 2.2682 + // when an event is called after a page has unloaded 2.2683 + return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? 2.2684 + jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : 2.2685 + undefined; 2.2686 + }; 2.2687 + // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events 2.2688 + eventHandle.elem = elem; 2.2689 + } 2.2690 + 2.2691 + // Handle multiple events separated by a space 2.2692 + // jQuery(...).bind("mouseover mouseout", fn); 2.2693 + types = jQuery.trim( hoverHack(types) ).split( " " ); 2.2694 + for ( t = 0; t < types.length; t++ ) { 2.2695 + 2.2696 + tns = rtypenamespace.exec( types[t] ) || []; 2.2697 + type = tns[1]; 2.2698 + namespaces = ( tns[2] || "" ).split( "." ).sort(); 2.2699 + 2.2700 + // If event changes its type, use the special event handlers for the changed type 2.2701 + special = jQuery.event.special[ type ] || {}; 2.2702 + 2.2703 + // If selector defined, determine special event api type, otherwise given type 2.2704 + type = ( selector ? special.delegateType : special.bindType ) || type; 2.2705 + 2.2706 + // Update special based on newly reset type 2.2707 + special = jQuery.event.special[ type ] || {}; 2.2708 + 2.2709 + // handleObj is passed to all event handlers 2.2710 + handleObj = jQuery.extend({ 2.2711 + type: type, 2.2712 + origType: tns[1], 2.2713 + data: data, 2.2714 + handler: handler, 2.2715 + guid: handler.guid, 2.2716 + selector: selector, 2.2717 + needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 2.2718 + namespace: namespaces.join(".") 2.2719 + }, handleObjIn ); 2.2720 + 2.2721 + // Init the event handler queue if we're the first 2.2722 + handlers = events[ type ]; 2.2723 + if ( !handlers ) { 2.2724 + handlers = events[ type ] = []; 2.2725 + handlers.delegateCount = 0; 2.2726 + 2.2727 + // Only use addEventListener/attachEvent if the special events handler returns false 2.2728 + if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 2.2729 + // Bind the global event handler to the element 2.2730 + if ( elem.addEventListener ) { 2.2731 + elem.addEventListener( type, eventHandle, false ); 2.2732 + 2.2733 + } else if ( elem.attachEvent ) { 2.2734 + elem.attachEvent( "on" + type, eventHandle ); 2.2735 + } 2.2736 + } 2.2737 + } 2.2738 + 2.2739 + if ( special.add ) { 2.2740 + special.add.call( elem, handleObj ); 2.2741 + 2.2742 + if ( !handleObj.handler.guid ) { 2.2743 + handleObj.handler.guid = handler.guid; 2.2744 + } 2.2745 + } 2.2746 + 2.2747 + // Add to the element's handler list, delegates in front 2.2748 + if ( selector ) { 2.2749 + handlers.splice( handlers.delegateCount++, 0, handleObj ); 2.2750 + } else { 2.2751 + handlers.push( handleObj ); 2.2752 + } 2.2753 + 2.2754 + // Keep track of which events have ever been used, for event optimization 2.2755 + jQuery.event.global[ type ] = true; 2.2756 + } 2.2757 + 2.2758 + // Nullify elem to prevent memory leaks in IE 2.2759 + elem = null; 2.2760 + }, 2.2761 + 2.2762 + global: {}, 2.2763 + 2.2764 + // Detach an event or set of events from an element 2.2765 + remove: function( elem, types, handler, selector, mappedTypes ) { 2.2766 + 2.2767 + var t, tns, type, origType, namespaces, origCount, 2.2768 + j, events, special, eventType, handleObj, 2.2769 + elemData = jQuery.hasData( elem ) && jQuery._data( elem ); 2.2770 + 2.2771 + if ( !elemData || !(events = elemData.events) ) { 2.2772 + return; 2.2773 + } 2.2774 + 2.2775 + // Once for each type.namespace in types; type may be omitted 2.2776 + types = jQuery.trim( hoverHack( types || "" ) ).split(" "); 2.2777 + for ( t = 0; t < types.length; t++ ) { 2.2778 + tns = rtypenamespace.exec( types[t] ) || []; 2.2779 + type = origType = tns[1]; 2.2780 + namespaces = tns[2]; 2.2781 + 2.2782 + // Unbind all events (on this namespace, if provided) for the element 2.2783 + if ( !type ) { 2.2784 + for ( type in events ) { 2.2785 + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 2.2786 + } 2.2787 + continue; 2.2788 + } 2.2789 + 2.2790 + special = jQuery.event.special[ type ] || {}; 2.2791 + type = ( selector? special.delegateType : special.bindType ) || type; 2.2792 + eventType = events[ type ] || []; 2.2793 + origCount = eventType.length; 2.2794 + namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null; 2.2795 + 2.2796 + // Remove matching events 2.2797 + for ( j = 0; j < eventType.length; j++ ) { 2.2798 + handleObj = eventType[ j ]; 2.2799 + 2.2800 + if ( ( mappedTypes || origType === handleObj.origType ) && 2.2801 + ( !handler || handler.guid === handleObj.guid ) && 2.2802 + ( !namespaces || namespaces.test( handleObj.namespace ) ) && 2.2803 + ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { 2.2804 + eventType.splice( j--, 1 ); 2.2805 + 2.2806 + if ( handleObj.selector ) { 2.2807 + eventType.delegateCount--; 2.2808 + } 2.2809 + if ( special.remove ) { 2.2810 + special.remove.call( elem, handleObj ); 2.2811 + } 2.2812 + } 2.2813 + } 2.2814 + 2.2815 + // Remove generic event handler if we removed something and no more handlers exist 2.2816 + // (avoids potential for endless recursion during removal of special event handlers) 2.2817 + if ( eventType.length === 0 && origCount !== eventType.length ) { 2.2818 + if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 2.2819 + jQuery.removeEvent( elem, type, elemData.handle ); 2.2820 + } 2.2821 + 2.2822 + delete events[ type ]; 2.2823 + } 2.2824 + } 2.2825 + 2.2826 + // Remove the expando if it's no longer used 2.2827 + if ( jQuery.isEmptyObject( events ) ) { 2.2828 + delete elemData.handle; 2.2829 + 2.2830 + // removeData also checks for emptiness and clears the expando if empty 2.2831 + // so use it instead of delete 2.2832 + jQuery.removeData( elem, "events", true ); 2.2833 + } 2.2834 + }, 2.2835 + 2.2836 + // Events that are safe to short-circuit if no handlers are attached. 2.2837 + // Native DOM events should not be added, they may have inline handlers. 2.2838 + customEvent: { 2.2839 + "getData": true, 2.2840 + "setData": true, 2.2841 + "changeData": true 2.2842 + }, 2.2843 + 2.2844 + trigger: function( event, data, elem, onlyHandlers ) { 2.2845 + // Don't do events on text and comment nodes 2.2846 + if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) { 2.2847 + return; 2.2848 + } 2.2849 + 2.2850 + // Event object or event type 2.2851 + var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType, 2.2852 + type = event.type || event, 2.2853 + namespaces = []; 2.2854 + 2.2855 + // focus/blur morphs to focusin/out; ensure we're not firing them right now 2.2856 + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 2.2857 + return; 2.2858 + } 2.2859 + 2.2860 + if ( type.indexOf( "!" ) >= 0 ) { 2.2861 + // Exclusive events trigger only for the exact event (no namespaces) 2.2862 + type = type.slice(0, -1); 2.2863 + exclusive = true; 2.2864 + } 2.2865 + 2.2866 + if ( type.indexOf( "." ) >= 0 ) { 2.2867 + // Namespaced trigger; create a regexp to match event type in handle() 2.2868 + namespaces = type.split("."); 2.2869 + type = namespaces.shift(); 2.2870 + namespaces.sort(); 2.2871 + } 2.2872 + 2.2873 + if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) { 2.2874 + // No jQuery handlers for this event type, and it can't have inline handlers 2.2875 + return; 2.2876 + } 2.2877 + 2.2878 + // Caller can pass in an Event, Object, or just an event type string 2.2879 + event = typeof event === "object" ? 2.2880 + // jQuery.Event object 2.2881 + event[ jQuery.expando ] ? event : 2.2882 + // Object literal 2.2883 + new jQuery.Event( type, event ) : 2.2884 + // Just the event type (string) 2.2885 + new jQuery.Event( type ); 2.2886 + 2.2887 + event.type = type; 2.2888 + event.isTrigger = true; 2.2889 + event.exclusive = exclusive; 2.2890 + event.namespace = namespaces.join( "." ); 2.2891 + event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; 2.2892 + ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; 2.2893 + 2.2894 + // Handle a global trigger 2.2895 + if ( !elem ) { 2.2896 + 2.2897 + // TODO: Stop taunting the data cache; remove global events and always attach to document 2.2898 + cache = jQuery.cache; 2.2899 + for ( i in cache ) { 2.2900 + if ( cache[ i ].events && cache[ i ].events[ type ] ) { 2.2901 + jQuery.event.trigger( event, data, cache[ i ].handle.elem, true ); 2.2902 + } 2.2903 + } 2.2904 + return; 2.2905 + } 2.2906 + 2.2907 + // Clean up the event in case it is being reused 2.2908 + event.result = undefined; 2.2909 + if ( !event.target ) { 2.2910 + event.target = elem; 2.2911 + } 2.2912 + 2.2913 + // Clone any incoming data and prepend the event, creating the handler arg list 2.2914 + data = data != null ? jQuery.makeArray( data ) : []; 2.2915 + data.unshift( event ); 2.2916 + 2.2917 + // Allow special events to draw outside the lines 2.2918 + special = jQuery.event.special[ type ] || {}; 2.2919 + if ( special.trigger && special.trigger.apply( elem, data ) === false ) { 2.2920 + return; 2.2921 + } 2.2922 + 2.2923 + // Determine event propagation path in advance, per W3C events spec (#9951) 2.2924 + // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) 2.2925 + eventPath = [[ elem, special.bindType || type ]]; 2.2926 + if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { 2.2927 + 2.2928 + bubbleType = special.delegateType || type; 2.2929 + cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; 2.2930 + for ( old = elem; cur; cur = cur.parentNode ) { 2.2931 + eventPath.push([ cur, bubbleType ]); 2.2932 + old = cur; 2.2933 + } 2.2934 + 2.2935 + // Only add window if we got to document (e.g., not plain obj or detached DOM) 2.2936 + if ( old === (elem.ownerDocument || document) ) { 2.2937 + eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); 2.2938 + } 2.2939 + } 2.2940 + 2.2941 + // Fire handlers on the event path 2.2942 + for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) { 2.2943 + 2.2944 + cur = eventPath[i][0]; 2.2945 + event.type = eventPath[i][1]; 2.2946 + 2.2947 + handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); 2.2948 + if ( handle ) { 2.2949 + handle.apply( cur, data ); 2.2950 + } 2.2951 + // Note that this is a bare JS function and not a jQuery handler 2.2952 + handle = ontype && cur[ ontype ]; 2.2953 + if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) { 2.2954 + event.preventDefault(); 2.2955 + } 2.2956 + } 2.2957 + event.type = type; 2.2958 + 2.2959 + // If nobody prevented the default action, do it now 2.2960 + if ( !onlyHandlers && !event.isDefaultPrevented() ) { 2.2961 + 2.2962 + if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && 2.2963 + !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { 2.2964 + 2.2965 + // Call a native DOM method on the target with the same name name as the event. 2.2966 + // Can't use an .isFunction() check here because IE6/7 fails that test. 2.2967 + // Don't do default actions on window, that's where global variables be (#6170) 2.2968 + // IE<9 dies on focus/blur to hidden element (#1486) 2.2969 + if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) { 2.2970 + 2.2971 + // Don't re-trigger an onFOO event when we call its FOO() method 2.2972 + old = elem[ ontype ]; 2.2973 + 2.2974 + if ( old ) { 2.2975 + elem[ ontype ] = null; 2.2976 + } 2.2977 + 2.2978 + // Prevent re-triggering of the same event, since we already bubbled it above 2.2979 + jQuery.event.triggered = type; 2.2980 + elem[ type ](); 2.2981 + jQuery.event.triggered = undefined; 2.2982 + 2.2983 + if ( old ) { 2.2984 + elem[ ontype ] = old; 2.2985 + } 2.2986 + } 2.2987 + } 2.2988 + } 2.2989 + 2.2990 + return event.result; 2.2991 + }, 2.2992 + 2.2993 + dispatch: function( event ) { 2.2994 + 2.2995 + // Make a writable jQuery.Event from the native event object 2.2996 + event = jQuery.event.fix( event || window.event ); 2.2997 + 2.2998 + var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related, 2.2999 + handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), 2.3000 + delegateCount = handlers.delegateCount, 2.3001 + args = core_slice.call( arguments ), 2.3002 + run_all = !event.exclusive && !event.namespace, 2.3003 + special = jQuery.event.special[ event.type ] || {}, 2.3004 + handlerQueue = []; 2.3005 + 2.3006 + // Use the fix-ed jQuery.Event rather than the (read-only) native event 2.3007 + args[0] = event; 2.3008 + event.delegateTarget = this; 2.3009 + 2.3010 + // Call the preDispatch hook for the mapped type, and let it bail if desired 2.3011 + if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { 2.3012 + return; 2.3013 + } 2.3014 + 2.3015 + // Determine handlers that should run if there are delegated events 2.3016 + // Avoid non-left-click bubbling in Firefox (#3861) 2.3017 + if ( delegateCount && !(event.button && event.type === "click") ) { 2.3018 + 2.3019 + for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { 2.3020 + 2.3021 + // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764) 2.3022 + if ( cur.disabled !== true || event.type !== "click" ) { 2.3023 + selMatch = {}; 2.3024 + matches = []; 2.3025 + for ( i = 0; i < delegateCount; i++ ) { 2.3026 + handleObj = handlers[ i ]; 2.3027 + sel = handleObj.selector; 2.3028 + 2.3029 + if ( selMatch[ sel ] === undefined ) { 2.3030 + selMatch[ sel ] = handleObj.needsContext ? 2.3031 + jQuery( sel, this ).index( cur ) >= 0 : 2.3032 + jQuery.find( sel, this, null, [ cur ] ).length; 2.3033 + } 2.3034 + if ( selMatch[ sel ] ) { 2.3035 + matches.push( handleObj ); 2.3036 + } 2.3037 + } 2.3038 + if ( matches.length ) { 2.3039 + handlerQueue.push({ elem: cur, matches: matches }); 2.3040 + } 2.3041 + } 2.3042 + } 2.3043 + } 2.3044 + 2.3045 + // Add the remaining (directly-bound) handlers 2.3046 + if ( handlers.length > delegateCount ) { 2.3047 + handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) }); 2.3048 + } 2.3049 + 2.3050 + // Run delegates first; they may want to stop propagation beneath us 2.3051 + for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) { 2.3052 + matched = handlerQueue[ i ]; 2.3053 + event.currentTarget = matched.elem; 2.3054 + 2.3055 + for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) { 2.3056 + handleObj = matched.matches[ j ]; 2.3057 + 2.3058 + // Triggered event must either 1) be non-exclusive and have no namespace, or 2.3059 + // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). 2.3060 + if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) { 2.3061 + 2.3062 + event.data = handleObj.data; 2.3063 + event.handleObj = handleObj; 2.3064 + 2.3065 + ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) 2.3066 + .apply( matched.elem, args ); 2.3067 + 2.3068 + if ( ret !== undefined ) { 2.3069 + event.result = ret; 2.3070 + if ( ret === false ) { 2.3071 + event.preventDefault(); 2.3072 + event.stopPropagation(); 2.3073 + } 2.3074 + } 2.3075 + } 2.3076 + } 2.3077 + } 2.3078 + 2.3079 + // Call the postDispatch hook for the mapped type 2.3080 + if ( special.postDispatch ) { 2.3081 + special.postDispatch.call( this, event ); 2.3082 + } 2.3083 + 2.3084 + return event.result; 2.3085 + }, 2.3086 + 2.3087 + // Includes some event props shared by KeyEvent and MouseEvent 2.3088 + // *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 *** 2.3089 + props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), 2.3090 + 2.3091 + fixHooks: {}, 2.3092 + 2.3093 + keyHooks: { 2.3094 + props: "char charCode key keyCode".split(" "), 2.3095 + filter: function( event, original ) { 2.3096 + 2.3097 + // Add which for key events 2.3098 + if ( event.which == null ) { 2.3099 + event.which = original.charCode != null ? original.charCode : original.keyCode; 2.3100 + } 2.3101 + 2.3102 + return event; 2.3103 + } 2.3104 + }, 2.3105 + 2.3106 + mouseHooks: { 2.3107 + props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), 2.3108 + filter: function( event, original ) { 2.3109 + var eventDoc, doc, body, 2.3110 + button = original.button, 2.3111 + fromElement = original.fromElement; 2.3112 + 2.3113 + // Calculate pageX/Y if missing and clientX/Y available 2.3114 + if ( event.pageX == null && original.clientX != null ) { 2.3115 + eventDoc = event.target.ownerDocument || document; 2.3116 + doc = eventDoc.documentElement; 2.3117 + body = eventDoc.body; 2.3118 + 2.3119 + event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); 2.3120 + event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); 2.3121 + } 2.3122 + 2.3123 + // Add relatedTarget, if necessary 2.3124 + if ( !event.relatedTarget && fromElement ) { 2.3125 + event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; 2.3126 + } 2.3127 + 2.3128 + // Add which for click: 1 === left; 2 === middle; 3 === right 2.3129 + // Note: button is not normalized, so don't use it 2.3130 + if ( !event.which && button !== undefined ) { 2.3131 + event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) ); 2.3132 + } 2.3133 + 2.3134 + return event; 2.3135 + } 2.3136 + }, 2.3137 + 2.3138 + fix: function( event ) { 2.3139 + if ( event[ jQuery.expando ] ) { 2.3140 + return event; 2.3141 + } 2.3142 + 2.3143 + // Create a writable copy of the event object and normalize some properties 2.3144 + var i, prop, 2.3145 + originalEvent = event, 2.3146 + fixHook = jQuery.event.fixHooks[ event.type ] || {}, 2.3147 + copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; 2.3148 + 2.3149 + event = jQuery.Event( originalEvent ); 2.3150 + 2.3151 + for ( i = copy.length; i; ) { 2.3152 + prop = copy[ --i ]; 2.3153 + event[ prop ] = originalEvent[ prop ]; 2.3154 + } 2.3155 + 2.3156 + // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2) 2.3157 + if ( !event.target ) { 2.3158 + event.target = originalEvent.srcElement || document; 2.3159 + } 2.3160 + 2.3161 + // Target should not be a text node (#504, Safari) 2.3162 + if ( event.target.nodeType === 3 ) { 2.3163 + event.target = event.target.parentNode; 2.3164 + } 2.3165 + 2.3166 + // For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8) 2.3167 + event.metaKey = !!event.metaKey; 2.3168 + 2.3169 + return fixHook.filter? fixHook.filter( event, originalEvent ) : event; 2.3170 + }, 2.3171 + 2.3172 + special: { 2.3173 + load: { 2.3174 + // Prevent triggered image.load events from bubbling to window.load 2.3175 + noBubble: true 2.3176 + }, 2.3177 + 2.3178 + focus: { 2.3179 + delegateType: "focusin" 2.3180 + }, 2.3181 + blur: { 2.3182 + delegateType: "focusout" 2.3183 + }, 2.3184 + 2.3185 + beforeunload: { 2.3186 + setup: function( data, namespaces, eventHandle ) { 2.3187 + // We only want to do this special case on windows 2.3188 + if ( jQuery.isWindow( this ) ) { 2.3189 + this.onbeforeunload = eventHandle; 2.3190 + } 2.3191 + }, 2.3192 + 2.3193 + teardown: function( namespaces, eventHandle ) { 2.3194 + if ( this.onbeforeunload === eventHandle ) { 2.3195 + this.onbeforeunload = null; 2.3196 + } 2.3197 + } 2.3198 + } 2.3199 + }, 2.3200 + 2.3201 + simulate: function( type, elem, event, bubble ) { 2.3202 + // Piggyback on a donor event to simulate a different one. 2.3203 + // Fake originalEvent to avoid donor's stopPropagation, but if the 2.3204 + // simulated event prevents default then we do the same on the donor. 2.3205 + var e = jQuery.extend( 2.3206 + new jQuery.Event(), 2.3207 + event, 2.3208 + { type: type, 2.3209 + isSimulated: true, 2.3210 + originalEvent: {} 2.3211 + } 2.3212 + ); 2.3213 + if ( bubble ) { 2.3214 + jQuery.event.trigger( e, null, elem ); 2.3215 + } else { 2.3216 + jQuery.event.dispatch.call( elem, e ); 2.3217 + } 2.3218 + if ( e.isDefaultPrevented() ) { 2.3219 + event.preventDefault(); 2.3220 + } 2.3221 + } 2.3222 +}; 2.3223 + 2.3224 +// Some plugins are using, but it's undocumented/deprecated and will be removed. 2.3225 +// The 1.7 special event interface should provide all the hooks needed now. 2.3226 +jQuery.event.handle = jQuery.event.dispatch; 2.3227 + 2.3228 +jQuery.removeEvent = document.removeEventListener ? 2.3229 + function( elem, type, handle ) { 2.3230 + if ( elem.removeEventListener ) { 2.3231 + elem.removeEventListener( type, handle, false ); 2.3232 + } 2.3233 + } : 2.3234 + function( elem, type, handle ) { 2.3235 + var name = "on" + type; 2.3236 + 2.3237 + if ( elem.detachEvent ) { 2.3238 + 2.3239 + // #8545, #7054, preventing memory leaks for custom events in IE6-8 – 2.3240 + // detachEvent needed property on element, by name of that event, to properly expose it to GC 2.3241 + if ( typeof elem[ name ] === "undefined" ) { 2.3242 + elem[ name ] = null; 2.3243 + } 2.3244 + 2.3245 + elem.detachEvent( name, handle ); 2.3246 + } 2.3247 + }; 2.3248 + 2.3249 +jQuery.Event = function( src, props ) { 2.3250 + // Allow instantiation without the 'new' keyword 2.3251 + if ( !(this instanceof jQuery.Event) ) { 2.3252 + return new jQuery.Event( src, props ); 2.3253 + } 2.3254 + 2.3255 + // Event object 2.3256 + if ( src && src.type ) { 2.3257 + this.originalEvent = src; 2.3258 + this.type = src.type; 2.3259 + 2.3260 + // Events bubbling up the document may have been marked as prevented 2.3261 + // by a handler lower down the tree; reflect the correct value. 2.3262 + this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false || 2.3263 + src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse; 2.3264 + 2.3265 + // Event type 2.3266 + } else { 2.3267 + this.type = src; 2.3268 + } 2.3269 + 2.3270 + // Put explicitly provided properties onto the event object 2.3271 + if ( props ) { 2.3272 + jQuery.extend( this, props ); 2.3273 + } 2.3274 + 2.3275 + // Create a timestamp if incoming event doesn't have one 2.3276 + this.timeStamp = src && src.timeStamp || jQuery.now(); 2.3277 + 2.3278 + // Mark it as fixed 2.3279 + this[ jQuery.expando ] = true; 2.3280 +}; 2.3281 + 2.3282 +function returnFalse() { 2.3283 + return false; 2.3284 +} 2.3285 +function returnTrue() { 2.3286 + return true; 2.3287 +} 2.3288 + 2.3289 +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 2.3290 +// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 2.3291 +jQuery.Event.prototype = { 2.3292 + preventDefault: function() { 2.3293 + this.isDefaultPrevented = returnTrue; 2.3294 + 2.3295 + var e = this.originalEvent; 2.3296 + if ( !e ) { 2.3297 + return; 2.3298 + } 2.3299 + 2.3300 + // if preventDefault exists run it on the original event 2.3301 + if ( e.preventDefault ) { 2.3302 + e.preventDefault(); 2.3303 + 2.3304 + // otherwise set the returnValue property of the original event to false (IE) 2.3305 + } else { 2.3306 + e.returnValue = false; 2.3307 + } 2.3308 + }, 2.3309 + stopPropagation: function() { 2.3310 + this.isPropagationStopped = returnTrue; 2.3311 + 2.3312 + var e = this.originalEvent; 2.3313 + if ( !e ) { 2.3314 + return; 2.3315 + } 2.3316 + // if stopPropagation exists run it on the original event 2.3317 + if ( e.stopPropagation ) { 2.3318 + e.stopPropagation(); 2.3319 + } 2.3320 + // otherwise set the cancelBubble property of the original event to true (IE) 2.3321 + e.cancelBubble = true; 2.3322 + }, 2.3323 + stopImmediatePropagation: function() { 2.3324 + this.isImmediatePropagationStopped = returnTrue; 2.3325 + this.stopPropagation(); 2.3326 + }, 2.3327 + isDefaultPrevented: returnFalse, 2.3328 + isPropagationStopped: returnFalse, 2.3329 + isImmediatePropagationStopped: returnFalse 2.3330 +}; 2.3331 + 2.3332 +// Create mouseenter/leave events using mouseover/out and event-time checks 2.3333 +jQuery.each({ 2.3334 + mouseenter: "mouseover", 2.3335 + mouseleave: "mouseout" 2.3336 +}, function( orig, fix ) { 2.3337 + jQuery.event.special[ orig ] = { 2.3338 + delegateType: fix, 2.3339 + bindType: fix, 2.3340 + 2.3341 + handle: function( event ) { 2.3342 + var ret, 2.3343 + target = this, 2.3344 + related = event.relatedTarget, 2.3345 + handleObj = event.handleObj, 2.3346 + selector = handleObj.selector; 2.3347 + 2.3348 + // For mousenter/leave call the handler if related is outside the target. 2.3349 + // NB: No relatedTarget if the mouse left/entered the browser window 2.3350 + if ( !related || (related !== target && !jQuery.contains( target, related )) ) { 2.3351 + event.type = handleObj.origType; 2.3352 + ret = handleObj.handler.apply( this, arguments ); 2.3353 + event.type = fix; 2.3354 + } 2.3355 + return ret; 2.3356 + } 2.3357 + }; 2.3358 +}); 2.3359 + 2.3360 +// IE submit delegation 2.3361 +if ( !jQuery.support.submitBubbles ) { 2.3362 + 2.3363 + jQuery.event.special.submit = { 2.3364 + setup: function() { 2.3365 + // Only need this for delegated form submit events 2.3366 + if ( jQuery.nodeName( this, "form" ) ) { 2.3367 + return false; 2.3368 + } 2.3369 + 2.3370 + // Lazy-add a submit handler when a descendant form may potentially be submitted 2.3371 + jQuery.event.add( this, "click._submit keypress._submit", function( e ) { 2.3372 + // Node name check avoids a VML-related crash in IE (#9807) 2.3373 + var elem = e.target, 2.3374 + form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; 2.3375 + if ( form && !jQuery._data( form, "_submit_attached" ) ) { 2.3376 + jQuery.event.add( form, "submit._submit", function( event ) { 2.3377 + event._submit_bubble = true; 2.3378 + }); 2.3379 + jQuery._data( form, "_submit_attached", true ); 2.3380 + } 2.3381 + }); 2.3382 + // return undefined since we don't need an event listener 2.3383 + }, 2.3384 + 2.3385 + postDispatch: function( event ) { 2.3386 + // If form was submitted by the user, bubble the event up the tree 2.3387 + if ( event._submit_bubble ) { 2.3388 + delete event._submit_bubble; 2.3389 + if ( this.parentNode && !event.isTrigger ) { 2.3390 + jQuery.event.simulate( "submit", this.parentNode, event, true ); 2.3391 + } 2.3392 + } 2.3393 + }, 2.3394 + 2.3395 + teardown: function() { 2.3396 + // Only need this for delegated form submit events 2.3397 + if ( jQuery.nodeName( this, "form" ) ) { 2.3398 + return false; 2.3399 + } 2.3400 + 2.3401 + // Remove delegated handlers; cleanData eventually reaps submit handlers attached above 2.3402 + jQuery.event.remove( this, "._submit" ); 2.3403 + } 2.3404 + }; 2.3405 +} 2.3406 + 2.3407 +// IE change delegation and checkbox/radio fix 2.3408 +if ( !jQuery.support.changeBubbles ) { 2.3409 + 2.3410 + jQuery.event.special.change = { 2.3411 + 2.3412 + setup: function() { 2.3413 + 2.3414 + if ( rformElems.test( this.nodeName ) ) { 2.3415 + // IE doesn't fire change on a check/radio until blur; trigger it on click 2.3416 + // after a propertychange. Eat the blur-change in special.change.handle. 2.3417 + // This still fires onchange a second time for check/radio after blur. 2.3418 + if ( this.type === "checkbox" || this.type === "radio" ) { 2.3419 + jQuery.event.add( this, "propertychange._change", function( event ) { 2.3420 + if ( event.originalEvent.propertyName === "checked" ) { 2.3421 + this._just_changed = true; 2.3422 + } 2.3423 + }); 2.3424 + jQuery.event.add( this, "click._change", function( event ) { 2.3425 + if ( this._just_changed && !event.isTrigger ) { 2.3426 + this._just_changed = false; 2.3427 + } 2.3428 + // Allow triggered, simulated change events (#11500) 2.3429 + jQuery.event.simulate( "change", this, event, true ); 2.3430 + }); 2.3431 + } 2.3432 + return false; 2.3433 + } 2.3434 + // Delegated event; lazy-add a change handler on descendant inputs 2.3435 + jQuery.event.add( this, "beforeactivate._change", function( e ) { 2.3436 + var elem = e.target; 2.3437 + 2.3438 + if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) { 2.3439 + jQuery.event.add( elem, "change._change", function( event ) { 2.3440 + if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { 2.3441 + jQuery.event.simulate( "change", this.parentNode, event, true ); 2.3442 + } 2.3443 + }); 2.3444 + jQuery._data( elem, "_change_attached", true ); 2.3445 + } 2.3446 + }); 2.3447 + }, 2.3448 + 2.3449 + handle: function( event ) { 2.3450 + var elem = event.target; 2.3451 + 2.3452 + // Swallow native change events from checkbox/radio, we already triggered them above 2.3453 + if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) { 2.3454 + return event.handleObj.handler.apply( this, arguments ); 2.3455 + } 2.3456 + }, 2.3457 + 2.3458 + teardown: function() { 2.3459 + jQuery.event.remove( this, "._change" ); 2.3460 + 2.3461 + return !rformElems.test( this.nodeName ); 2.3462 + } 2.3463 + }; 2.3464 +} 2.3465 + 2.3466 +// Create "bubbling" focus and blur events 2.3467 +if ( !jQuery.support.focusinBubbles ) { 2.3468 + jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { 2.3469 + 2.3470 + // Attach a single capturing handler while someone wants focusin/focusout 2.3471 + var attaches = 0, 2.3472 + handler = function( event ) { 2.3473 + jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true ); 2.3474 + }; 2.3475 + 2.3476 + jQuery.event.special[ fix ] = { 2.3477 + setup: function() { 2.3478 + if ( attaches++ === 0 ) { 2.3479 + document.addEventListener( orig, handler, true ); 2.3480 + } 2.3481 + }, 2.3482 + teardown: function() { 2.3483 + if ( --attaches === 0 ) { 2.3484 + document.removeEventListener( orig, handler, true ); 2.3485 + } 2.3486 + } 2.3487 + }; 2.3488 + }); 2.3489 +} 2.3490 + 2.3491 +jQuery.fn.extend({ 2.3492 + 2.3493 + on: function( types, selector, data, fn, /*INTERNAL*/ one ) { 2.3494 + var origFn, type; 2.3495 + 2.3496 + // Types can be a map of types/handlers 2.3497 + if ( typeof types === "object" ) { 2.3498 + // ( types-Object, selector, data ) 2.3499 + if ( typeof selector !== "string" ) { // && selector != null 2.3500 + // ( types-Object, data ) 2.3501 + data = data || selector; 2.3502 + selector = undefined; 2.3503 + } 2.3504 + for ( type in types ) { 2.3505 + this.on( type, selector, data, types[ type ], one ); 2.3506 + } 2.3507 + return this; 2.3508 + } 2.3509 + 2.3510 + if ( data == null && fn == null ) { 2.3511 + // ( types, fn ) 2.3512 + fn = selector; 2.3513 + data = selector = undefined; 2.3514 + } else if ( fn == null ) { 2.3515 + if ( typeof selector === "string" ) { 2.3516 + // ( types, selector, fn ) 2.3517 + fn = data; 2.3518 + data = undefined; 2.3519 + } else { 2.3520 + // ( types, data, fn ) 2.3521 + fn = data; 2.3522 + data = selector; 2.3523 + selector = undefined; 2.3524 + } 2.3525 + } 2.3526 + if ( fn === false ) { 2.3527 + fn = returnFalse; 2.3528 + } else if ( !fn ) { 2.3529 + return this; 2.3530 + } 2.3531 + 2.3532 + if ( one === 1 ) { 2.3533 + origFn = fn; 2.3534 + fn = function( event ) { 2.3535 + // Can use an empty set, since event contains the info 2.3536 + jQuery().off( event ); 2.3537 + return origFn.apply( this, arguments ); 2.3538 + }; 2.3539 + // Use same guid so caller can remove using origFn 2.3540 + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 2.3541 + } 2.3542 + return this.each( function() { 2.3543 + jQuery.event.add( this, types, fn, data, selector ); 2.3544 + }); 2.3545 + }, 2.3546 + one: function( types, selector, data, fn ) { 2.3547 + return this.on( types, selector, data, fn, 1 ); 2.3548 + }, 2.3549 + off: function( types, selector, fn ) { 2.3550 + var handleObj, type; 2.3551 + if ( types && types.preventDefault && types.handleObj ) { 2.3552 + // ( event ) dispatched jQuery.Event 2.3553 + handleObj = types.handleObj; 2.3554 + jQuery( types.delegateTarget ).off( 2.3555 + handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, 2.3556 + handleObj.selector, 2.3557 + handleObj.handler 2.3558 + ); 2.3559 + return this; 2.3560 + } 2.3561 + if ( typeof types === "object" ) { 2.3562 + // ( types-object [, selector] ) 2.3563 + for ( type in types ) { 2.3564 + this.off( type, selector, types[ type ] ); 2.3565 + } 2.3566 + return this; 2.3567 + } 2.3568 + if ( selector === false || typeof selector === "function" ) { 2.3569 + // ( types [, fn] ) 2.3570 + fn = selector; 2.3571 + selector = undefined; 2.3572 + } 2.3573 + if ( fn === false ) { 2.3574 + fn = returnFalse; 2.3575 + } 2.3576 + return this.each(function() { 2.3577 + jQuery.event.remove( this, types, fn, selector ); 2.3578 + }); 2.3579 + }, 2.3580 + 2.3581 + bind: function( types, data, fn ) { 2.3582 + return this.on( types, null, data, fn ); 2.3583 + }, 2.3584 + unbind: function( types, fn ) { 2.3585 + return this.off( types, null, fn ); 2.3586 + }, 2.3587 + 2.3588 + live: function( types, data, fn ) { 2.3589 + jQuery( this.context ).on( types, this.selector, data, fn ); 2.3590 + return this; 2.3591 + }, 2.3592 + die: function( types, fn ) { 2.3593 + jQuery( this.context ).off( types, this.selector || "**", fn ); 2.3594 + return this; 2.3595 + }, 2.3596 + 2.3597 + delegate: function( selector, types, data, fn ) { 2.3598 + return this.on( types, selector, data, fn ); 2.3599 + }, 2.3600 + undelegate: function( selector, types, fn ) { 2.3601 + // ( namespace ) or ( selector, types [, fn] ) 2.3602 + return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn ); 2.3603 + }, 2.3604 + 2.3605 + trigger: function( type, data ) { 2.3606 + return this.each(function() { 2.3607 + jQuery.event.trigger( type, data, this ); 2.3608 + }); 2.3609 + }, 2.3610 + triggerHandler: function( type, data ) { 2.3611 + if ( this[0] ) { 2.3612 + return jQuery.event.trigger( type, data, this[0], true ); 2.3613 + } 2.3614 + }, 2.3615 + 2.3616 + toggle: function( fn ) { 2.3617 + // Save reference to arguments for access in closure 2.3618 + var args = arguments, 2.3619 + guid = fn.guid || jQuery.guid++, 2.3620 + i = 0, 2.3621 + toggler = function( event ) { 2.3622 + // Figure out which function to execute 2.3623 + var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; 2.3624 + jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); 2.3625 + 2.3626 + // Make sure that clicks stop 2.3627 + event.preventDefault(); 2.3628 + 2.3629 + // and execute the function 2.3630 + return args[ lastToggle ].apply( this, arguments ) || false; 2.3631 + }; 2.3632 + 2.3633 + // link all the functions, so any of them can unbind this click handler 2.3634 + toggler.guid = guid; 2.3635 + while ( i < args.length ) { 2.3636 + args[ i++ ].guid = guid; 2.3637 + } 2.3638 + 2.3639 + return this.click( toggler ); 2.3640 + }, 2.3641 + 2.3642 + hover: function( fnOver, fnOut ) { 2.3643 + return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); 2.3644 + } 2.3645 +}); 2.3646 + 2.3647 +jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " + 2.3648 + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 2.3649 + "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) { 2.3650 + 2.3651 + // Handle event binding 2.3652 + jQuery.fn[ name ] = function( data, fn ) { 2.3653 + if ( fn == null ) { 2.3654 + fn = data; 2.3655 + data = null; 2.3656 + } 2.3657 + 2.3658 + return arguments.length > 0 ? 2.3659 + this.on( name, null, data, fn ) : 2.3660 + this.trigger( name ); 2.3661 + }; 2.3662 + 2.3663 + if ( rkeyEvent.test( name ) ) { 2.3664 + jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks; 2.3665 + } 2.3666 + 2.3667 + if ( rmouseEvent.test( name ) ) { 2.3668 + jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks; 2.3669 + } 2.3670 +}); 2.3671 +/*! 2.3672 + * Sizzle CSS Selector Engine 2.3673 + * Copyright 2012 jQuery Foundation and other contributors 2.3674 + * Released under the MIT license 2.3675 + * http://sizzlejs.com/ 2.3676 + */ 2.3677 +(function( window, undefined ) { 2.3678 + 2.3679 +var cachedruns, 2.3680 + assertGetIdNotName, 2.3681 + Expr, 2.3682 + getText, 2.3683 + isXML, 2.3684 + contains, 2.3685 + compile, 2.3686 + sortOrder, 2.3687 + hasDuplicate, 2.3688 + outermostContext, 2.3689 + 2.3690 + baseHasDuplicate = true, 2.3691 + strundefined = "undefined", 2.3692 + 2.3693 + expando = ( "sizcache" + Math.random() ).replace( ".", "" ), 2.3694 + 2.3695 + Token = String, 2.3696 + document = window.document, 2.3697 + docElem = document.documentElement, 2.3698 + dirruns = 0, 2.3699 + done = 0, 2.3700 + pop = [].pop, 2.3701 + push = [].push, 2.3702 + slice = [].slice, 2.3703 + // Use a stripped-down indexOf if a native one is unavailable 2.3704 + indexOf = [].indexOf || function( elem ) { 2.3705 + var i = 0, 2.3706 + len = this.length; 2.3707 + for ( ; i < len; i++ ) { 2.3708 + if ( this[i] === elem ) { 2.3709 + return i; 2.3710 + } 2.3711 + } 2.3712 + return -1; 2.3713 + }, 2.3714 + 2.3715 + // Augment a function for special use by Sizzle 2.3716 + markFunction = function( fn, value ) { 2.3717 + fn[ expando ] = value == null || value; 2.3718 + return fn; 2.3719 + }, 2.3720 + 2.3721 + createCache = function() { 2.3722 + var cache = {}, 2.3723 + keys = []; 2.3724 + 2.3725 + return markFunction(function( key, value ) { 2.3726 + // Only keep the most recent entries 2.3727 + if ( keys.push( key ) > Expr.cacheLength ) { 2.3728 + delete cache[ keys.shift() ]; 2.3729 + } 2.3730 + 2.3731 + return (cache[ key ] = value); 2.3732 + }, cache ); 2.3733 + }, 2.3734 + 2.3735 + classCache = createCache(), 2.3736 + tokenCache = createCache(), 2.3737 + compilerCache = createCache(), 2.3738 + 2.3739 + // Regex 2.3740 + 2.3741 + // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace 2.3742 + whitespace = "[\\x20\\t\\r\\n\\f]", 2.3743 + // http://www.w3.org/TR/css3-syntax/#characters 2.3744 + characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+", 2.3745 + 2.3746 + // Loosely modeled on CSS identifier characters 2.3747 + // An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors) 2.3748 + // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier 2.3749 + identifier = characterEncoding.replace( "w", "w#" ), 2.3750 + 2.3751 + // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors 2.3752 + operators = "([*^$|!~]?=)", 2.3753 + attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + 2.3754 + "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", 2.3755 + 2.3756 + // Prefer arguments not in parens/brackets, 2.3757 + // then attribute selectors and non-pseudos (denoted by :), 2.3758 + // then anything else 2.3759 + // These preferences are here to reduce the number of selectors 2.3760 + // needing tokenize in the PSEUDO preFilter 2.3761 + pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)", 2.3762 + 2.3763 + // For matchExpr.POS and matchExpr.needsContext 2.3764 + pos = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + 2.3765 + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", 2.3766 + 2.3767 + // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 2.3768 + rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), 2.3769 + 2.3770 + rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 2.3771 + rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ), 2.3772 + rpseudo = new RegExp( pseudos ), 2.3773 + 2.3774 + // Easily-parseable/retrievable ID or TAG or CLASS selectors 2.3775 + rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/, 2.3776 + 2.3777 + rnot = /^:not/, 2.3778 + rsibling = /[\x20\t\r\n\f]*[+~]/, 2.3779 + rendsWithNot = /:not\($/, 2.3780 + 2.3781 + rheader = /h\d/i, 2.3782 + rinputs = /input|select|textarea|button/i, 2.3783 + 2.3784 + rbackslash = /\\(?!\\)/g, 2.3785 + 2.3786 + matchExpr = { 2.3787 + "ID": new RegExp( "^#(" + characterEncoding + ")" ), 2.3788 + "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), 2.3789 + "NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ), 2.3790 + "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), 2.3791 + "ATTR": new RegExp( "^" + attributes ), 2.3792 + "PSEUDO": new RegExp( "^" + pseudos ), 2.3793 + "POS": new RegExp( pos, "i" ), 2.3794 + "CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace + 2.3795 + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + 2.3796 + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 2.3797 + // For use in libraries implementing .is() 2.3798 + "needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" ) 2.3799 + }, 2.3800 + 2.3801 + // Support 2.3802 + 2.3803 + // Used for testing something on an element 2.3804 + assert = function( fn ) { 2.3805 + var div = document.createElement("div"); 2.3806 + 2.3807 + try { 2.3808 + return fn( div ); 2.3809 + } catch (e) { 2.3810 + return false; 2.3811 + } finally { 2.3812 + // release memory in IE 2.3813 + div = null; 2.3814 + } 2.3815 + }, 2.3816 + 2.3817 + // Check if getElementsByTagName("*") returns only elements 2.3818 + assertTagNameNoComments = assert(function( div ) { 2.3819 + div.appendChild( document.createComment("") ); 2.3820 + return !div.getElementsByTagName("*").length; 2.3821 + }), 2.3822 + 2.3823 + // Check if getAttribute returns normalized href attributes 2.3824 + assertHrefNotNormalized = assert(function( div ) { 2.3825 + div.innerHTML = "<a href='#'></a>"; 2.3826 + return div.firstChild && typeof div.firstChild.getAttribute !== strundefined && 2.3827 + div.firstChild.getAttribute("href") === "#"; 2.3828 + }), 2.3829 + 2.3830 + // Check if attributes should be retrieved by attribute nodes 2.3831 + assertAttributes = assert(function( div ) { 2.3832 + div.innerHTML = "<select></select>"; 2.3833 + var type = typeof div.lastChild.getAttribute("multiple"); 2.3834 + // IE8 returns a string for some attributes even when not present 2.3835 + return type !== "boolean" && type !== "string"; 2.3836 + }), 2.3837 + 2.3838 + // Check if getElementsByClassName can be trusted 2.3839 + assertUsableClassName = assert(function( div ) { 2.3840 + // Opera can't find a second classname (in 9.6) 2.3841 + div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>"; 2.3842 + if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) { 2.3843 + return false; 2.3844 + } 2.3845 + 2.3846 + // Safari 3.2 caches class attributes and doesn't catch changes 2.3847 + div.lastChild.className = "e"; 2.3848 + return div.getElementsByClassName("e").length === 2; 2.3849 + }), 2.3850 + 2.3851 + // Check if getElementById returns elements by name 2.3852 + // Check if getElementsByName privileges form controls or returns elements by ID 2.3853 + assertUsableName = assert(function( div ) { 2.3854 + // Inject content 2.3855 + div.id = expando + 0; 2.3856 + div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>"; 2.3857 + docElem.insertBefore( div, docElem.firstChild ); 2.3858 + 2.3859 + // Test 2.3860 + var pass = document.getElementsByName && 2.3861 + // buggy browsers will return fewer than the correct 2 2.3862 + document.getElementsByName( expando ).length === 2 + 2.3863 + // buggy browsers will return more than the correct 0 2.3864 + document.getElementsByName( expando + 0 ).length; 2.3865 + assertGetIdNotName = !document.getElementById( expando ); 2.3866 + 2.3867 + // Cleanup 2.3868 + docElem.removeChild( div ); 2.3869 + 2.3870 + return pass; 2.3871 + }); 2.3872 + 2.3873 +// If slice is not available, provide a backup 2.3874 +try { 2.3875 + slice.call( docElem.childNodes, 0 )[0].nodeType; 2.3876 +} catch ( e ) { 2.3877 + slice = function( i ) { 2.3878 + var elem, 2.3879 + results = []; 2.3880 + for ( ; (elem = this[i]); i++ ) { 2.3881 + results.push( elem ); 2.3882 + } 2.3883 + return results; 2.3884 + }; 2.3885 +} 2.3886 + 2.3887 +function Sizzle( selector, context, results, seed ) { 2.3888 + results = results || []; 2.3889 + context = context || document; 2.3890 + var match, elem, xml, m, 2.3891 + nodeType = context.nodeType; 2.3892 + 2.3893 + if ( !selector || typeof selector !== "string" ) { 2.3894 + return results; 2.3895 + } 2.3896 + 2.3897 + if ( nodeType !== 1 && nodeType !== 9 ) { 2.3898 + return []; 2.3899 + } 2.3900 + 2.3901 + xml = isXML( context ); 2.3902 + 2.3903 + if ( !xml && !seed ) { 2.3904 + if ( (match = rquickExpr.exec( selector )) ) { 2.3905 + // Speed-up: Sizzle("#ID") 2.3906 + if ( (m = match[1]) ) { 2.3907 + if ( nodeType === 9 ) { 2.3908 + elem = context.getElementById( m ); 2.3909 + // Check parentNode to catch when Blackberry 4.6 returns 2.3910 + // nodes that are no longer in the document #6963 2.3911 + if ( elem && elem.parentNode ) { 2.3912 + // Handle the case where IE, Opera, and Webkit return items 2.3913 + // by name instead of ID 2.3914 + if ( elem.id === m ) { 2.3915 + results.push( elem ); 2.3916 + return results; 2.3917 + } 2.3918 + } else { 2.3919 + return results; 2.3920 + } 2.3921 + } else { 2.3922 + // Context is not a document 2.3923 + if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && 2.3924 + contains( context, elem ) && elem.id === m ) { 2.3925 + results.push( elem ); 2.3926 + return results; 2.3927 + } 2.3928 + } 2.3929 + 2.3930 + // Speed-up: Sizzle("TAG") 2.3931 + } else if ( match[2] ) { 2.3932 + push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) ); 2.3933 + return results; 2.3934 + 2.3935 + // Speed-up: Sizzle(".CLASS") 2.3936 + } else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) { 2.3937 + push.apply( results, slice.call(context.getElementsByClassName( m ), 0) ); 2.3938 + return results; 2.3939 + } 2.3940 + } 2.3941 + } 2.3942 + 2.3943 + // All others 2.3944 + return select( selector.replace( rtrim, "$1" ), context, results, seed, xml ); 2.3945 +} 2.3946 + 2.3947 +Sizzle.matches = function( expr, elements ) { 2.3948 + return Sizzle( expr, null, null, elements ); 2.3949 +}; 2.3950 + 2.3951 +Sizzle.matchesSelector = function( elem, expr ) { 2.3952 + return Sizzle( expr, null, null, [ elem ] ).length > 0; 2.3953 +}; 2.3954 + 2.3955 +// Returns a function to use in pseudos for input types 2.3956 +function createInputPseudo( type ) { 2.3957 + return function( elem ) { 2.3958 + var name = elem.nodeName.toLowerCase(); 2.3959 + return name === "input" && elem.type === type; 2.3960 + }; 2.3961 +} 2.3962 + 2.3963 +// Returns a function to use in pseudos for buttons 2.3964 +function createButtonPseudo( type ) { 2.3965 + return function( elem ) { 2.3966 + var name = elem.nodeName.toLowerCase(); 2.3967 + return (name === "input" || name === "button") && elem.type === type; 2.3968 + }; 2.3969 +} 2.3970 + 2.3971 +// Returns a function to use in pseudos for positionals 2.3972 +function createPositionalPseudo( fn ) { 2.3973 + return markFunction(function( argument ) { 2.3974 + argument = +argument; 2.3975 + return markFunction(function( seed, matches ) { 2.3976 + var j, 2.3977 + matchIndexes = fn( [], seed.length, argument ), 2.3978 + i = matchIndexes.length; 2.3979 + 2.3980 + // Match elements found at the specified indexes 2.3981 + while ( i-- ) { 2.3982 + if ( seed[ (j = matchIndexes[i]) ] ) { 2.3983 + seed[j] = !(matches[j] = seed[j]); 2.3984 + } 2.3985 + } 2.3986 + }); 2.3987 + }); 2.3988 +} 2.3989 + 2.3990 +/** 2.3991 + * Utility function for retrieving the text value of an array of DOM nodes 2.3992 + * @param {Array|Element} elem 2.3993 + */ 2.3994 +getText = Sizzle.getText = function( elem ) { 2.3995 + var node, 2.3996 + ret = "", 2.3997 + i = 0, 2.3998 + nodeType = elem.nodeType; 2.3999 + 2.4000 + if ( nodeType ) { 2.4001 + if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 2.4002 + // Use textContent for elements 2.4003 + // innerText usage removed for consistency of new lines (see #11153) 2.4004 + if ( typeof elem.textContent === "string" ) { 2.4005 + return elem.textContent; 2.4006 + } else { 2.4007 + // Traverse its children 2.4008 + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 2.4009 + ret += getText( elem ); 2.4010 + } 2.4011 + } 2.4012 + } else if ( nodeType === 3 || nodeType === 4 ) { 2.4013 + return elem.nodeValue; 2.4014 + } 2.4015 + // Do not include comment or processing instruction nodes 2.4016 + } else { 2.4017 + 2.4018 + // If no nodeType, this is expected to be an array 2.4019 + for ( ; (node = elem[i]); i++ ) { 2.4020 + // Do not traverse comment nodes 2.4021 + ret += getText( node ); 2.4022 + } 2.4023 + } 2.4024 + return ret; 2.4025 +}; 2.4026 + 2.4027 +isXML = Sizzle.isXML = function( elem ) { 2.4028 + // documentElement is verified for cases where it doesn't yet exist 2.4029 + // (such as loading iframes in IE - #4833) 2.4030 + var documentElement = elem && (elem.ownerDocument || elem).documentElement; 2.4031 + return documentElement ? documentElement.nodeName !== "HTML" : false; 2.4032 +}; 2.4033 + 2.4034 +// Element contains another 2.4035 +contains = Sizzle.contains = docElem.contains ? 2.4036 + function( a, b ) { 2.4037 + var adown = a.nodeType === 9 ? a.documentElement : a, 2.4038 + bup = b && b.parentNode; 2.4039 + return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) ); 2.4040 + } : 2.4041 + docElem.compareDocumentPosition ? 2.4042 + function( a, b ) { 2.4043 + return b && !!( a.compareDocumentPosition( b ) & 16 ); 2.4044 + } : 2.4045 + function( a, b ) { 2.4046 + while ( (b = b.parentNode) ) { 2.4047 + if ( b === a ) { 2.4048 + return true; 2.4049 + } 2.4050 + } 2.4051 + return false; 2.4052 + }; 2.4053 + 2.4054 +Sizzle.attr = function( elem, name ) { 2.4055 + var val, 2.4056 + xml = isXML( elem ); 2.4057 + 2.4058 + if ( !xml ) { 2.4059 + name = name.toLowerCase(); 2.4060 + } 2.4061 + if ( (val = Expr.attrHandle[ name ]) ) { 2.4062 + return val( elem ); 2.4063 + } 2.4064 + if ( xml || assertAttributes ) { 2.4065 + return elem.getAttribute( name ); 2.4066 + } 2.4067 + val = elem.getAttributeNode( name ); 2.4068 + return val ? 2.4069 + typeof elem[ name ] === "boolean" ? 2.4070 + elem[ name ] ? name : null : 2.4071 + val.specified ? val.value : null : 2.4072 + null; 2.4073 +}; 2.4074 + 2.4075 +Expr = Sizzle.selectors = { 2.4076 + 2.4077 + // Can be adjusted by the user 2.4078 + cacheLength: 50, 2.4079 + 2.4080 + createPseudo: markFunction, 2.4081 + 2.4082 + match: matchExpr, 2.4083 + 2.4084 + // IE6/7 return a modified href 2.4085 + attrHandle: assertHrefNotNormalized ? 2.4086 + {} : 2.4087 + { 2.4088 + "href": function( elem ) { 2.4089 + return elem.getAttribute( "href", 2 ); 2.4090 + }, 2.4091 + "type": function( elem ) { 2.4092 + return elem.getAttribute("type"); 2.4093 + } 2.4094 + }, 2.4095 + 2.4096 + find: { 2.4097 + "ID": assertGetIdNotName ? 2.4098 + function( id, context, xml ) { 2.4099 + if ( typeof context.getElementById !== strundefined && !xml ) { 2.4100 + var m = context.getElementById( id ); 2.4101 + // Check parentNode to catch when Blackberry 4.6 returns 2.4102 + // nodes that are no longer in the document #6963 2.4103 + return m && m.parentNode ? [m] : []; 2.4104 + } 2.4105 + } : 2.4106 + function( id, context, xml ) { 2.4107 + if ( typeof context.getElementById !== strundefined && !xml ) { 2.4108 + var m = context.getElementById( id ); 2.4109 + 2.4110 + return m ? 2.4111 + m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? 2.4112 + [m] : 2.4113 + undefined : 2.4114 + []; 2.4115 + } 2.4116 + }, 2.4117 + 2.4118 + "TAG": assertTagNameNoComments ? 2.4119 + function( tag, context ) { 2.4120 + if ( typeof context.getElementsByTagName !== strundefined ) { 2.4121 + return context.getElementsByTagName( tag ); 2.4122 + } 2.4123 + } : 2.4124 + function( tag, context ) { 2.4125 + var results = context.getElementsByTagName( tag ); 2.4126 + 2.4127 + // Filter out possible comments 2.4128 + if ( tag === "*" ) { 2.4129 + var elem, 2.4130 + tmp = [], 2.4131 + i = 0; 2.4132 + 2.4133 + for ( ; (elem = results[i]); i++ ) { 2.4134 + if ( elem.nodeType === 1 ) { 2.4135 + tmp.push( elem ); 2.4136 + } 2.4137 + } 2.4138 + 2.4139 + return tmp; 2.4140 + } 2.4141 + return results; 2.4142 + }, 2.4143 + 2.4144 + "NAME": assertUsableName && function( tag, context ) { 2.4145 + if ( typeof context.getElementsByName !== strundefined ) { 2.4146 + return context.getElementsByName( name ); 2.4147 + } 2.4148 + }, 2.4149 + 2.4150 + "CLASS": assertUsableClassName && function( className, context, xml ) { 2.4151 + if ( typeof context.getElementsByClassName !== strundefined && !xml ) { 2.4152 + return context.getElementsByClassName( className ); 2.4153 + } 2.4154 + } 2.4155 + }, 2.4156 + 2.4157 + relative: { 2.4158 + ">": { dir: "parentNode", first: true }, 2.4159 + " ": { dir: "parentNode" }, 2.4160 + "+": { dir: "previousSibling", first: true }, 2.4161 + "~": { dir: "previousSibling" } 2.4162 + }, 2.4163 + 2.4164 + preFilter: { 2.4165 + "ATTR": function( match ) { 2.4166 + match[1] = match[1].replace( rbackslash, "" ); 2.4167 + 2.4168 + // Move the given value to match[3] whether quoted or unquoted 2.4169 + match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" ); 2.4170 + 2.4171 + if ( match[2] === "~=" ) { 2.4172 + match[3] = " " + match[3] + " "; 2.4173 + } 2.4174 + 2.4175 + return match.slice( 0, 4 ); 2.4176 + }, 2.4177 + 2.4178 + "CHILD": function( match ) { 2.4179 + /* matches from matchExpr["CHILD"] 2.4180 + 1 type (only|nth|...) 2.4181 + 2 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 2.4182 + 3 xn-component of xn+y argument ([+-]?\d*n|) 2.4183 + 4 sign of xn-component 2.4184 + 5 x of xn-component 2.4185 + 6 sign of y-component 2.4186 + 7 y of y-component 2.4187 + */ 2.4188 + match[1] = match[1].toLowerCase(); 2.4189 + 2.4190 + if ( match[1] === "nth" ) { 2.4191 + // nth-child requires argument 2.4192 + if ( !match[2] ) { 2.4193 + Sizzle.error( match[0] ); 2.4194 + } 2.4195 + 2.4196 + // numeric x and y parameters for Expr.filter.CHILD 2.4197 + // remember that false/true cast respectively to 0/1 2.4198 + match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) ); 2.4199 + match[4] = +( ( match[6] + match[7] ) || match[2] === "odd" ); 2.4200 + 2.4201 + // other types prohibit arguments 2.4202 + } else if ( match[2] ) { 2.4203 + Sizzle.error( match[0] ); 2.4204 + } 2.4205 + 2.4206 + return match; 2.4207 + }, 2.4208 + 2.4209 + "PSEUDO": function( match ) { 2.4210 + var unquoted, excess; 2.4211 + if ( matchExpr["CHILD"].test( match[0] ) ) { 2.4212 + return null; 2.4213 + } 2.4214 + 2.4215 + if ( match[3] ) { 2.4216 + match[2] = match[3]; 2.4217 + } else if ( (unquoted = match[4]) ) { 2.4218 + // Only check arguments that contain a pseudo 2.4219 + if ( rpseudo.test(unquoted) && 2.4220 + // Get excess from tokenize (recursively) 2.4221 + (excess = tokenize( unquoted, true )) && 2.4222 + // advance to the next closing parenthesis 2.4223 + (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { 2.4224 + 2.4225 + // excess is a negative index 2.4226 + unquoted = unquoted.slice( 0, excess ); 2.4227 + match[0] = match[0].slice( 0, excess ); 2.4228 + } 2.4229 + match[2] = unquoted; 2.4230 + } 2.4231 + 2.4232 + // Return only captures needed by the pseudo filter method (type and argument) 2.4233 + return match.slice( 0, 3 ); 2.4234 + } 2.4235 + }, 2.4236 + 2.4237 + filter: { 2.4238 + "ID": assertGetIdNotName ? 2.4239 + function( id ) { 2.4240 + id = id.replace( rbackslash, "" ); 2.4241 + return function( elem ) { 2.4242 + return elem.getAttribute("id") === id; 2.4243 + }; 2.4244 + } : 2.4245 + function( id ) { 2.4246 + id = id.replace( rbackslash, "" ); 2.4247 + return function( elem ) { 2.4248 + var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); 2.4249 + return node && node.value === id; 2.4250 + }; 2.4251 + }, 2.4252 + 2.4253 + "TAG": function( nodeName ) { 2.4254 + if ( nodeName === "*" ) { 2.4255 + return function() { return true; }; 2.4256 + } 2.4257 + nodeName = nodeName.replace( rbackslash, "" ).toLowerCase(); 2.4258 + 2.4259 + return function( elem ) { 2.4260 + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; 2.4261 + }; 2.4262 + }, 2.4263 + 2.4264 + "CLASS": function( className ) { 2.4265 + var pattern = classCache[ expando ][ className ]; 2.4266 + if ( !pattern ) { 2.4267 + pattern = classCache( className, new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)") ); 2.4268 + } 2.4269 + return function( elem ) { 2.4270 + return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" ); 2.4271 + }; 2.4272 + }, 2.4273 + 2.4274 + "ATTR": function( name, operator, check ) { 2.4275 + return function( elem, context ) { 2.4276 + var result = Sizzle.attr( elem, name ); 2.4277 + 2.4278 + if ( result == null ) { 2.4279 + return operator === "!="; 2.4280 + } 2.4281 + if ( !operator ) { 2.4282 + return true; 2.4283 + } 2.4284 + 2.4285 + result += ""; 2.4286 + 2.4287 + return operator === "=" ? result === check : 2.4288 + operator === "!=" ? result !== check : 2.4289 + operator === "^=" ? check && result.indexOf( check ) === 0 : 2.4290 + operator === "*=" ? check && result.indexOf( check ) > -1 : 2.4291 + operator === "$=" ? check && result.substr( result.length - check.length ) === check : 2.4292 + operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 : 2.4293 + operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" : 2.4294 + false; 2.4295 + }; 2.4296 + }, 2.4297 + 2.4298 + "CHILD": function( type, argument, first, last ) { 2.4299 + 2.4300 + if ( type === "nth" ) { 2.4301 + return function( elem ) { 2.4302 + var node, diff, 2.4303 + parent = elem.parentNode; 2.4304 + 2.4305 + if ( first === 1 && last === 0 ) { 2.4306 + return true; 2.4307 + } 2.4308 + 2.4309 + if ( parent ) { 2.4310 + diff = 0; 2.4311 + for ( node = parent.firstChild; node; node = node.nextSibling ) { 2.4312 + if ( node.nodeType === 1 ) { 2.4313 + diff++; 2.4314 + if ( elem === node ) { 2.4315 + break; 2.4316 + } 2.4317 + } 2.4318 + } 2.4319 + } 2.4320 + 2.4321 + // Incorporate the offset (or cast to NaN), then check against cycle size 2.4322 + diff -= last; 2.4323 + return diff === first || ( diff % first === 0 && diff / first >= 0 ); 2.4324 + }; 2.4325 + } 2.4326 + 2.4327 + return function( elem ) { 2.4328 + var node = elem; 2.4329 + 2.4330 + switch ( type ) { 2.4331 + case "only": 2.4332 + case "first": 2.4333 + while ( (node = node.previousSibling) ) { 2.4334 + if ( node.nodeType === 1 ) { 2.4335 + return false; 2.4336 + } 2.4337 + } 2.4338 + 2.4339 + if ( type === "first" ) { 2.4340 + return true; 2.4341 + } 2.4342 + 2.4343 + node = elem; 2.4344 + 2.4345 + /* falls through */ 2.4346 + case "last": 2.4347 + while ( (node = node.nextSibling) ) { 2.4348 + if ( node.nodeType === 1 ) { 2.4349 + return false; 2.4350 + } 2.4351 + } 2.4352 + 2.4353 + return true; 2.4354 + } 2.4355 + }; 2.4356 + }, 2.4357 + 2.4358 + "PSEUDO": function( pseudo, argument ) { 2.4359 + // pseudo-class names are case-insensitive 2.4360 + // http://www.w3.org/TR/selectors/#pseudo-classes 2.4361 + // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 2.4362 + // Remember that setFilters inherits from pseudos 2.4363 + var args, 2.4364 + fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 2.4365 + Sizzle.error( "unsupported pseudo: " + pseudo ); 2.4366 + 2.4367 + // The user may use createPseudo to indicate that 2.4368 + // arguments are needed to create the filter function 2.4369 + // just as Sizzle does 2.4370 + if ( fn[ expando ] ) { 2.4371 + return fn( argument ); 2.4372 + } 2.4373 + 2.4374 + // But maintain support for old signatures 2.4375 + if ( fn.length > 1 ) { 2.4376 + args = [ pseudo, pseudo, "", argument ]; 2.4377 + return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 2.4378 + markFunction(function( seed, matches ) { 2.4379 + var idx, 2.4380 + matched = fn( seed, argument ), 2.4381 + i = matched.length; 2.4382 + while ( i-- ) { 2.4383 + idx = indexOf.call( seed, matched[i] ); 2.4384 + seed[ idx ] = !( matches[ idx ] = matched[i] ); 2.4385 + } 2.4386 + }) : 2.4387 + function( elem ) { 2.4388 + return fn( elem, 0, args ); 2.4389 + }; 2.4390 + } 2.4391 + 2.4392 + return fn; 2.4393 + } 2.4394 + }, 2.4395 + 2.4396 + pseudos: { 2.4397 + "not": markFunction(function( selector ) { 2.4398 + // Trim the selector passed to compile 2.4399 + // to avoid treating leading and trailing 2.4400 + // spaces as combinators 2.4401 + var input = [], 2.4402 + results = [], 2.4403 + matcher = compile( selector.replace( rtrim, "$1" ) ); 2.4404 + 2.4405 + return matcher[ expando ] ? 2.4406 + markFunction(function( seed, matches, context, xml ) { 2.4407 + var elem, 2.4408 + unmatched = matcher( seed, null, xml, [] ), 2.4409 + i = seed.length; 2.4410 + 2.4411 + // Match elements unmatched by `matcher` 2.4412 + while ( i-- ) { 2.4413 + if ( (elem = unmatched[i]) ) { 2.4414 + seed[i] = !(matches[i] = elem); 2.4415 + } 2.4416 + } 2.4417 + }) : 2.4418 + function( elem, context, xml ) { 2.4419 + input[0] = elem; 2.4420 + matcher( input, null, xml, results ); 2.4421 + return !results.pop(); 2.4422 + }; 2.4423 + }), 2.4424 + 2.4425 + "has": markFunction(function( selector ) { 2.4426 + return function( elem ) { 2.4427 + return Sizzle( selector, elem ).length > 0; 2.4428 + }; 2.4429 + }), 2.4430 + 2.4431 + "contains": markFunction(function( text ) { 2.4432 + return function( elem ) { 2.4433 + return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; 2.4434 + }; 2.4435 + }), 2.4436 + 2.4437 + "enabled": function( elem ) { 2.4438 + return elem.disabled === false; 2.4439 + }, 2.4440 + 2.4441 + "disabled": function( elem ) { 2.4442 + return elem.disabled === true; 2.4443 + }, 2.4444 + 2.4445 + "checked": function( elem ) { 2.4446 + // In CSS3, :checked should return both checked and selected elements 2.4447 + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 2.4448 + var nodeName = elem.nodeName.toLowerCase(); 2.4449 + return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); 2.4450 + }, 2.4451 + 2.4452 + "selected": function( elem ) { 2.4453 + // Accessing this property makes selected-by-default 2.4454 + // options in Safari work properly 2.4455 + if ( elem.parentNode ) { 2.4456 + elem.parentNode.selectedIndex; 2.4457 + } 2.4458 + 2.4459 + return elem.selected === true; 2.4460 + }, 2.4461 + 2.4462 + "parent": function( elem ) { 2.4463 + return !Expr.pseudos["empty"]( elem ); 2.4464 + }, 2.4465 + 2.4466 + "empty": function( elem ) { 2.4467 + // http://www.w3.org/TR/selectors/#empty-pseudo 2.4468 + // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)), 2.4469 + // not comment, processing instructions, or others 2.4470 + // Thanks to Diego Perini for the nodeName shortcut 2.4471 + // Greater than "@" means alpha characters (specifically not starting with "#" or "?") 2.4472 + var nodeType; 2.4473 + elem = elem.firstChild; 2.4474 + while ( elem ) { 2.4475 + if ( elem.nodeName > "@" || (nodeType = elem.nodeType) === 3 || nodeType === 4 ) { 2.4476 + return false; 2.4477 + } 2.4478 + elem = elem.nextSibling; 2.4479 + } 2.4480 + return true; 2.4481 + }, 2.4482 + 2.4483 + "header": function( elem ) { 2.4484 + return rheader.test( elem.nodeName ); 2.4485 + }, 2.4486 + 2.4487 + "text": function( elem ) { 2.4488 + var type, attr; 2.4489 + // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 2.4490 + // use getAttribute instead to test this case 2.4491 + return elem.nodeName.toLowerCase() === "input" && 2.4492 + (type = elem.type) === "text" && 2.4493 + ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === type ); 2.4494 + }, 2.4495 + 2.4496 + // Input types 2.4497 + "radio": createInputPseudo("radio"), 2.4498 + "checkbox": createInputPseudo("checkbox"), 2.4499 + "file": createInputPseudo("file"), 2.4500 + "password": createInputPseudo("password"), 2.4501 + "image": createInputPseudo("image"), 2.4502 + 2.4503 + "submit": createButtonPseudo("submit"), 2.4504 + "reset": createButtonPseudo("reset"), 2.4505 + 2.4506 + "button": function( elem ) { 2.4507 + var name = elem.nodeName.toLowerCase(); 2.4508 + return name === "input" && elem.type === "button" || name === "button"; 2.4509 + }, 2.4510 + 2.4511 + "input": function( elem ) { 2.4512 + return rinputs.test( elem.nodeName ); 2.4513 + }, 2.4514 + 2.4515 + "focus": function( elem ) { 2.4516 + var doc = elem.ownerDocument; 2.4517 + return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href); 2.4518 + }, 2.4519 + 2.4520 + "active": function( elem ) { 2.4521 + return elem === elem.ownerDocument.activeElement; 2.4522 + }, 2.4523 + 2.4524 + // Positional types 2.4525 + "first": createPositionalPseudo(function( matchIndexes, length, argument ) { 2.4526 + return [ 0 ]; 2.4527 + }), 2.4528 + 2.4529 + "last": createPositionalPseudo(function( matchIndexes, length, argument ) { 2.4530 + return [ length - 1 ]; 2.4531 + }), 2.4532 + 2.4533 + "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { 2.4534 + return [ argument < 0 ? argument + length : argument ]; 2.4535 + }), 2.4536 + 2.4537 + "even": createPositionalPseudo(function( matchIndexes, length, argument ) { 2.4538 + for ( var i = 0; i < length; i += 2 ) { 2.4539 + matchIndexes.push( i ); 2.4540 + } 2.4541 + return matchIndexes; 2.4542 + }), 2.4543 + 2.4544 + "odd": createPositionalPseudo(function( matchIndexes, length, argument ) { 2.4545 + for ( var i = 1; i < length; i += 2 ) { 2.4546 + matchIndexes.push( i ); 2.4547 + } 2.4548 + return matchIndexes; 2.4549 + }), 2.4550 + 2.4551 + "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { 2.4552 + for ( var i = argument < 0 ? argument + length : argument; --i >= 0; ) { 2.4553 + matchIndexes.push( i ); 2.4554 + } 2.4555 + return matchIndexes; 2.4556 + }), 2.4557 + 2.4558 + "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { 2.4559 + for ( var i = argument < 0 ? argument + length : argument; ++i < length; ) { 2.4560 + matchIndexes.push( i ); 2.4561 + } 2.4562 + return matchIndexes; 2.4563 + }) 2.4564 + } 2.4565 +}; 2.4566 + 2.4567 +function siblingCheck( a, b, ret ) { 2.4568 + if ( a === b ) { 2.4569 + return ret; 2.4570 + } 2.4571 + 2.4572 + var cur = a.nextSibling; 2.4573 + 2.4574 + while ( cur ) { 2.4575 + if ( cur === b ) { 2.4576 + return -1; 2.4577 + } 2.4578 + 2.4579 + cur = cur.nextSibling; 2.4580 + } 2.4581 + 2.4582 + return 1; 2.4583 +} 2.4584 + 2.4585 +sortOrder = docElem.compareDocumentPosition ? 2.4586 + function( a, b ) { 2.4587 + if ( a === b ) { 2.4588 + hasDuplicate = true; 2.4589 + return 0; 2.4590 + } 2.4591 + 2.4592 + return ( !a.compareDocumentPosition || !b.compareDocumentPosition ? 2.4593 + a.compareDocumentPosition : 2.4594 + a.compareDocumentPosition(b) & 4 2.4595 + ) ? -1 : 1; 2.4596 + } : 2.4597 + function( a, b ) { 2.4598 + // The nodes are identical, we can exit early 2.4599 + if ( a === b ) { 2.4600 + hasDuplicate = true; 2.4601 + return 0; 2.4602 + 2.4603 + // Fallback to using sourceIndex (in IE) if it's available on both nodes 2.4604 + } else if ( a.sourceIndex && b.sourceIndex ) { 2.4605 + return a.sourceIndex - b.sourceIndex; 2.4606 + } 2.4607 + 2.4608 + var al, bl, 2.4609 + ap = [], 2.4610 + bp = [], 2.4611 + aup = a.parentNode, 2.4612 + bup = b.parentNode, 2.4613 + cur = aup; 2.4614 + 2.4615 + // If the nodes are siblings (or identical) we can do a quick check 2.4616 + if ( aup === bup ) { 2.4617 + return siblingCheck( a, b ); 2.4618 + 2.4619 + // If no parents were found then the nodes are disconnected 2.4620 + } else if ( !aup ) { 2.4621 + return -1; 2.4622 + 2.4623 + } else if ( !bup ) { 2.4624 + return 1; 2.4625 + } 2.4626 + 2.4627 + // Otherwise they're somewhere else in the tree so we need 2.4628 + // to build up a full list of the parentNodes for comparison 2.4629 + while ( cur ) { 2.4630 + ap.unshift( cur ); 2.4631 + cur = cur.parentNode; 2.4632 + } 2.4633 + 2.4634 + cur = bup; 2.4635 + 2.4636 + while ( cur ) { 2.4637 + bp.unshift( cur ); 2.4638 + cur = cur.parentNode; 2.4639 + } 2.4640 + 2.4641 + al = ap.length; 2.4642 + bl = bp.length; 2.4643 + 2.4644 + // Start walking down the tree looking for a discrepancy 2.4645 + for ( var i = 0; i < al && i < bl; i++ ) { 2.4646 + if ( ap[i] !== bp[i] ) { 2.4647 + return siblingCheck( ap[i], bp[i] ); 2.4648 + } 2.4649 + } 2.4650 + 2.4651 + // We ended someplace up the tree so do a sibling check 2.4652 + return i === al ? 2.4653 + siblingCheck( a, bp[i], -1 ) : 2.4654 + siblingCheck( ap[i], b, 1 ); 2.4655 + }; 2.4656 + 2.4657 +// Always assume the presence of duplicates if sort doesn't 2.4658 +// pass them to our comparison function (as in Google Chrome). 2.4659 +[0, 0].sort( sortOrder ); 2.4660 +baseHasDuplicate = !hasDuplicate; 2.4661 + 2.4662 +// Document sorting and removing duplicates 2.4663 +Sizzle.uniqueSort = function( results ) { 2.4664 + var elem, 2.4665 + i = 1; 2.4666 + 2.4667 + hasDuplicate = baseHasDuplicate; 2.4668 + results.sort( sortOrder ); 2.4669 + 2.4670 + if ( hasDuplicate ) { 2.4671 + for ( ; (elem = results[i]); i++ ) { 2.4672 + if ( elem === results[ i - 1 ] ) { 2.4673 + results.splice( i--, 1 ); 2.4674 + } 2.4675 + } 2.4676 + } 2.4677 + 2.4678 + return results; 2.4679 +}; 2.4680 + 2.4681 +Sizzle.error = function( msg ) { 2.4682 + throw new Error( "Syntax error, unrecognized expression: " + msg ); 2.4683 +}; 2.4684 + 2.4685 +function tokenize( selector, parseOnly ) { 2.4686 + var matched, match, tokens, type, soFar, groups, preFilters, 2.4687 + cached = tokenCache[ expando ][ selector ]; 2.4688 + 2.4689 + if ( cached ) { 2.4690 + return parseOnly ? 0 : cached.slice( 0 ); 2.4691 + } 2.4692 + 2.4693 + soFar = selector; 2.4694 + groups = []; 2.4695 + preFilters = Expr.preFilter; 2.4696 + 2.4697 + while ( soFar ) { 2.4698 + 2.4699 + // Comma and first run 2.4700 + if ( !matched || (match = rcomma.exec( soFar )) ) { 2.4701 + if ( match ) { 2.4702 + soFar = soFar.slice( match[0].length ); 2.4703 + } 2.4704 + groups.push( tokens = [] ); 2.4705 + } 2.4706 + 2.4707 + matched = false; 2.4708 + 2.4709 + // Combinators 2.4710 + if ( (match = rcombinators.exec( soFar )) ) { 2.4711 + tokens.push( matched = new Token( match.shift() ) ); 2.4712 + soFar = soFar.slice( matched.length ); 2.4713 + 2.4714 + // Cast descendant combinators to space 2.4715 + matched.type = match[0].replace( rtrim, " " ); 2.4716 + } 2.4717 + 2.4718 + // Filters 2.4719 + for ( type in Expr.filter ) { 2.4720 + if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || 2.4721 + // The last two arguments here are (context, xml) for backCompat 2.4722 + (match = preFilters[ type ]( match, document, true ))) ) { 2.4723 + 2.4724 + tokens.push( matched = new Token( match.shift() ) ); 2.4725 + soFar = soFar.slice( matched.length ); 2.4726 + matched.type = type; 2.4727 + matched.matches = match; 2.4728 + } 2.4729 + } 2.4730 + 2.4731 + if ( !matched ) { 2.4732 + break; 2.4733 + } 2.4734 + } 2.4735 + 2.4736 + // Return the length of the invalid excess 2.4737 + // if we're just parsing 2.4738 + // Otherwise, throw an error or return tokens 2.4739 + return parseOnly ? 2.4740 + soFar.length : 2.4741 + soFar ? 2.4742 + Sizzle.error( selector ) : 2.4743 + // Cache the tokens 2.4744 + tokenCache( selector, groups ).slice( 0 ); 2.4745 +} 2.4746 + 2.4747 +function addCombinator( matcher, combinator, base ) { 2.4748 + var dir = combinator.dir, 2.4749 + checkNonElements = base && combinator.dir === "parentNode", 2.4750 + doneName = done++; 2.4751 + 2.4752 + return combinator.first ? 2.4753 + // Check against closest ancestor/preceding element 2.4754 + function( elem, context, xml ) { 2.4755 + while ( (elem = elem[ dir ]) ) { 2.4756 + if ( checkNonElements || elem.nodeType === 1 ) { 2.4757 + return matcher( elem, context, xml ); 2.4758 + } 2.4759 + } 2.4760 + } : 2.4761 + 2.4762 + // Check against all ancestor/preceding elements 2.4763 + function( elem, context, xml ) { 2.4764 + // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching 2.4765 + if ( !xml ) { 2.4766 + var cache, 2.4767 + dirkey = dirruns + " " + doneName + " ", 2.4768 + cachedkey = dirkey + cachedruns; 2.4769 + while ( (elem = elem[ dir ]) ) { 2.4770 + if ( checkNonElements || elem.nodeType === 1 ) { 2.4771 + if ( (cache = elem[ expando ]) === cachedkey ) { 2.4772 + return elem.sizset; 2.4773 + } else if ( typeof cache === "string" && cache.indexOf(dirkey) === 0 ) { 2.4774 + if ( elem.sizset ) { 2.4775 + return elem; 2.4776 + } 2.4777 + } else { 2.4778 + elem[ expando ] = cachedkey; 2.4779 + if ( matcher( elem, context, xml ) ) { 2.4780 + elem.sizset = true; 2.4781 + return elem; 2.4782 + } 2.4783 + elem.sizset = false; 2.4784 + } 2.4785 + } 2.4786 + } 2.4787 + } else { 2.4788 + while ( (elem = elem[ dir ]) ) { 2.4789 + if ( checkNonElements || elem.nodeType === 1 ) { 2.4790 + if ( matcher( elem, context, xml ) ) { 2.4791 + return elem; 2.4792 + } 2.4793 + } 2.4794 + } 2.4795 + } 2.4796 + }; 2.4797 +} 2.4798 + 2.4799 +function elementMatcher( matchers ) { 2.4800 + return matchers.length > 1 ? 2.4801 + function( elem, context, xml ) { 2.4802 + var i = matchers.length; 2.4803 + while ( i-- ) { 2.4804 + if ( !matchers[i]( elem, context, xml ) ) { 2.4805 + return false; 2.4806 + } 2.4807 + } 2.4808 + return true; 2.4809 + } : 2.4810 + matchers[0]; 2.4811 +} 2.4812 + 2.4813 +function condense( unmatched, map, filter, context, xml ) { 2.4814 + var elem, 2.4815 + newUnmatched = [], 2.4816 + i = 0, 2.4817 + len = unmatched.length, 2.4818 + mapped = map != null; 2.4819 + 2.4820 + for ( ; i < len; i++ ) { 2.4821 + if ( (elem = unmatched[i]) ) { 2.4822 + if ( !filter || filter( elem, context, xml ) ) { 2.4823 + newUnmatched.push( elem ); 2.4824 + if ( mapped ) { 2.4825 + map.push( i ); 2.4826 + } 2.4827 + } 2.4828 + } 2.4829 + } 2.4830 + 2.4831 + return newUnmatched; 2.4832 +} 2.4833 + 2.4834 +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 2.4835 + if ( postFilter && !postFilter[ expando ] ) { 2.4836 + postFilter = setMatcher( postFilter ); 2.4837 + } 2.4838 + if ( postFinder && !postFinder[ expando ] ) { 2.4839 + postFinder = setMatcher( postFinder, postSelector ); 2.4840 + } 2.4841 + return markFunction(function( seed, results, context, xml ) { 2.4842 + // Positional selectors apply to seed elements, so it is invalid to follow them with relative ones 2.4843 + if ( seed && postFinder ) { 2.4844 + return; 2.4845 + } 2.4846 + 2.4847 + var i, elem, postFilterIn, 2.4848 + preMap = [], 2.4849 + postMap = [], 2.4850 + preexisting = results.length, 2.4851 + 2.4852 + // Get initial elements from seed or context 2.4853 + elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [], seed ), 2.4854 + 2.4855 + // Prefilter to get matcher input, preserving a map for seed-results synchronization 2.4856 + matcherIn = preFilter && ( seed || !selector ) ? 2.4857 + condense( elems, preMap, preFilter, context, xml ) : 2.4858 + elems, 2.4859 + 2.4860 + matcherOut = matcher ? 2.4861 + // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, 2.4862 + postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 2.4863 + 2.4864 + // ...intermediate processing is necessary 2.4865 + [] : 2.4866 + 2.4867 + // ...otherwise use results directly 2.4868 + results : 2.4869 + matcherIn; 2.4870 + 2.4871 + // Find primary matches 2.4872 + if ( matcher ) { 2.4873 + matcher( matcherIn, matcherOut, context, xml ); 2.4874 + } 2.4875 + 2.4876 + // Apply postFilter 2.4877 + if ( postFilter ) { 2.4878 + postFilterIn = condense( matcherOut, postMap ); 2.4879 + postFilter( postFilterIn, [], context, xml ); 2.4880 + 2.4881 + // Un-match failing elements by moving them back to matcherIn 2.4882 + i = postFilterIn.length; 2.4883 + while ( i-- ) { 2.4884 + if ( (elem = postFilterIn[i]) ) { 2.4885 + matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); 2.4886 + } 2.4887 + } 2.4888 + } 2.4889 + 2.4890 + // Keep seed and results synchronized 2.4891 + if ( seed ) { 2.4892 + // Ignore postFinder because it can't coexist with seed 2.4893 + i = preFilter && matcherOut.length; 2.4894 + while ( i-- ) { 2.4895 + if ( (elem = matcherOut[i]) ) { 2.4896 + seed[ preMap[i] ] = !(results[ preMap[i] ] = elem); 2.4897 + } 2.4898 + } 2.4899 + } else { 2.4900 + matcherOut = condense( 2.4901 + matcherOut === results ? 2.4902 + matcherOut.splice( preexisting, matcherOut.length ) : 2.4903 + matcherOut 2.4904 + ); 2.4905 + if ( postFinder ) { 2.4906 + postFinder( null, results, matcherOut, xml ); 2.4907 + } else { 2.4908 + push.apply( results, matcherOut ); 2.4909 + } 2.4910 + } 2.4911 + }); 2.4912 +} 2.4913 + 2.4914 +function matcherFromTokens( tokens ) { 2.4915 + var checkContext, matcher, j, 2.4916 + len = tokens.length, 2.4917 + leadingRelative = Expr.relative[ tokens[0].type ], 2.4918 + implicitRelative = leadingRelative || Expr.relative[" "], 2.4919 + i = leadingRelative ? 1 : 0, 2.4920 + 2.4921 + // The foundational matcher ensures that elements are reachable from top-level context(s) 2.4922 + matchContext = addCombinator( function( elem ) { 2.4923 + return elem === checkContext; 2.4924 + }, implicitRelative, true ), 2.4925 + matchAnyContext = addCombinator( function( elem ) { 2.4926 + return indexOf.call( checkContext, elem ) > -1; 2.4927 + }, implicitRelative, true ), 2.4928 + matchers = [ function( elem, context, xml ) { 2.4929 + return ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( 2.4930 + (checkContext = context).nodeType ? 2.4931 + matchContext( elem, context, xml ) : 2.4932 + matchAnyContext( elem, context, xml ) ); 2.4933 + } ]; 2.4934 + 2.4935 + for ( ; i < len; i++ ) { 2.4936 + if ( (matcher = Expr.relative[ tokens[i].type ]) ) { 2.4937 + matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; 2.4938 + } else { 2.4939 + // The concatenated values are (context, xml) for backCompat 2.4940 + matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); 2.4941 + 2.4942 + // Return special upon seeing a positional matcher 2.4943 + if ( matcher[ expando ] ) { 2.4944 + // Find the next relative operator (if any) for proper handling 2.4945 + j = ++i; 2.4946 + for ( ; j < len; j++ ) { 2.4947 + if ( Expr.relative[ tokens[j].type ] ) { 2.4948 + break; 2.4949 + } 2.4950 + } 2.4951 + return setMatcher( 2.4952 + i > 1 && elementMatcher( matchers ), 2.4953 + i > 1 && tokens.slice( 0, i - 1 ).join("").replace( rtrim, "$1" ), 2.4954 + matcher, 2.4955 + i < j && matcherFromTokens( tokens.slice( i, j ) ), 2.4956 + j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), 2.4957 + j < len && tokens.join("") 2.4958 + ); 2.4959 + } 2.4960 + matchers.push( matcher ); 2.4961 + } 2.4962 + } 2.4963 + 2.4964 + return elementMatcher( matchers ); 2.4965 +} 2.4966 + 2.4967 +function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 2.4968 + var bySet = setMatchers.length > 0, 2.4969 + byElement = elementMatchers.length > 0, 2.4970 + superMatcher = function( seed, context, xml, results, expandContext ) { 2.4971 + var elem, j, matcher, 2.4972 + setMatched = [], 2.4973 + matchedCount = 0, 2.4974 + i = "0", 2.4975 + unmatched = seed && [], 2.4976 + outermost = expandContext != null, 2.4977 + contextBackup = outermostContext, 2.4978 + // We must always have either seed elements or context 2.4979 + elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ), 2.4980 + // Nested matchers should use non-integer dirruns 2.4981 + dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.E); 2.4982 + 2.4983 + if ( outermost ) { 2.4984 + outermostContext = context !== document && context; 2.4985 + cachedruns = superMatcher.el; 2.4986 + } 2.4987 + 2.4988 + // Add elements passing elementMatchers directly to results 2.4989 + for ( ; (elem = elems[i]) != null; i++ ) { 2.4990 + if ( byElement && elem ) { 2.4991 + for ( j = 0; (matcher = elementMatchers[j]); j++ ) { 2.4992 + if ( matcher( elem, context, xml ) ) { 2.4993 + results.push( elem ); 2.4994 + break; 2.4995 + } 2.4996 + } 2.4997 + if ( outermost ) { 2.4998 + dirruns = dirrunsUnique; 2.4999 + cachedruns = ++superMatcher.el; 2.5000 + } 2.5001 + } 2.5002 + 2.5003 + // Track unmatched elements for set filters 2.5004 + if ( bySet ) { 2.5005 + // They will have gone through all possible matchers 2.5006 + if ( (elem = !matcher && elem) ) { 2.5007 + matchedCount--; 2.5008 + } 2.5009 + 2.5010 + // Lengthen the array for every element, matched or not 2.5011 + if ( seed ) { 2.5012 + unmatched.push( elem ); 2.5013 + } 2.5014 + } 2.5015 + } 2.5016 + 2.5017 + // Apply set filters to unmatched elements 2.5018 + matchedCount += i; 2.5019 + if ( bySet && i !== matchedCount ) { 2.5020 + for ( j = 0; (matcher = setMatchers[j]); j++ ) { 2.5021 + matcher( unmatched, setMatched, context, xml ); 2.5022 + } 2.5023 + 2.5024 + if ( seed ) { 2.5025 + // Reintegrate element matches to eliminate the need for sorting 2.5026 + if ( matchedCount > 0 ) { 2.5027 + while ( i-- ) { 2.5028 + if ( !(unmatched[i] || setMatched[i]) ) { 2.5029 + setMatched[i] = pop.call( results ); 2.5030 + } 2.5031 + } 2.5032 + } 2.5033 + 2.5034 + // Discard index placeholder values to get only actual matches 2.5035 + setMatched = condense( setMatched ); 2.5036 + } 2.5037 + 2.5038 + // Add matches to results 2.5039 + push.apply( results, setMatched ); 2.5040 + 2.5041 + // Seedless set matches succeeding multiple successful matchers stipulate sorting 2.5042 + if ( outermost && !seed && setMatched.length > 0 && 2.5043 + ( matchedCount + setMatchers.length ) > 1 ) { 2.5044 + 2.5045 + Sizzle.uniqueSort( results ); 2.5046 + } 2.5047 + } 2.5048 + 2.5049 + // Override manipulation of globals by nested matchers 2.5050 + if ( outermost ) { 2.5051 + dirruns = dirrunsUnique; 2.5052 + outermostContext = contextBackup; 2.5053 + } 2.5054 + 2.5055 + return unmatched; 2.5056 + }; 2.5057 + 2.5058 + superMatcher.el = 0; 2.5059 + return bySet ? 2.5060 + markFunction( superMatcher ) : 2.5061 + superMatcher; 2.5062 +} 2.5063 + 2.5064 +compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) { 2.5065 + var i, 2.5066 + setMatchers = [], 2.5067 + elementMatchers = [], 2.5068 + cached = compilerCache[ expando ][ selector ]; 2.5069 + 2.5070 + if ( !cached ) { 2.5071 + // Generate a function of recursive functions that can be used to check each element 2.5072 + if ( !group ) { 2.5073 + group = tokenize( selector ); 2.5074 + } 2.5075 + i = group.length; 2.5076 + while ( i-- ) { 2.5077 + cached = matcherFromTokens( group[i] ); 2.5078 + if ( cached[ expando ] ) { 2.5079 + setMatchers.push( cached ); 2.5080 + } else { 2.5081 + elementMatchers.push( cached ); 2.5082 + } 2.5083 + } 2.5084 + 2.5085 + // Cache the compiled function 2.5086 + cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 2.5087 + } 2.5088 + return cached; 2.5089 +}; 2.5090 + 2.5091 +function multipleContexts( selector, contexts, results, seed ) { 2.5092 + var i = 0, 2.5093 + len = contexts.length; 2.5094 + for ( ; i < len; i++ ) { 2.5095 + Sizzle( selector, contexts[i], results, seed ); 2.5096 + } 2.5097 + return results; 2.5098 +} 2.5099 + 2.5100 +function select( selector, context, results, seed, xml ) { 2.5101 + var i, tokens, token, type, find, 2.5102 + match = tokenize( selector ), 2.5103 + j = match.length; 2.5104 + 2.5105 + if ( !seed ) { 2.5106 + // Try to minimize operations if there is only one group 2.5107 + if ( match.length === 1 ) { 2.5108 + 2.5109 + // Take a shortcut and set the context if the root selector is an ID 2.5110 + tokens = match[0] = match[0].slice( 0 ); 2.5111 + if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && 2.5112 + context.nodeType === 9 && !xml && 2.5113 + Expr.relative[ tokens[1].type ] ) { 2.5114 + 2.5115 + context = Expr.find["ID"]( token.matches[0].replace( rbackslash, "" ), context, xml )[0]; 2.5116 + if ( !context ) { 2.5117 + return results; 2.5118 + } 2.5119 + 2.5120 + selector = selector.slice( tokens.shift().length ); 2.5121 + } 2.5122 + 2.5123 + // Fetch a seed set for right-to-left matching 2.5124 + for ( i = matchExpr["POS"].test( selector ) ? -1 : tokens.length - 1; i >= 0; i-- ) { 2.5125 + token = tokens[i]; 2.5126 + 2.5127 + // Abort if we hit a combinator 2.5128 + if ( Expr.relative[ (type = token.type) ] ) { 2.5129 + break; 2.5130 + } 2.5131 + if ( (find = Expr.find[ type ]) ) { 2.5132 + // Search, expanding context for leading sibling combinators 2.5133 + if ( (seed = find( 2.5134 + token.matches[0].replace( rbackslash, "" ), 2.5135 + rsibling.test( tokens[0].type ) && context.parentNode || context, 2.5136 + xml 2.5137 + )) ) { 2.5138 + 2.5139 + // If seed is empty or no tokens remain, we can return early 2.5140 + tokens.splice( i, 1 ); 2.5141 + selector = seed.length && tokens.join(""); 2.5142 + if ( !selector ) { 2.5143 + push.apply( results, slice.call( seed, 0 ) ); 2.5144 + return results; 2.5145 + } 2.5146 + 2.5147 + break; 2.5148 + } 2.5149 + } 2.5150 + } 2.5151 + } 2.5152 + } 2.5153 + 2.5154 + // Compile and execute a filtering function 2.5155 + // Provide `match` to avoid retokenization if we modified the selector above 2.5156 + compile( selector, match )( 2.5157 + seed, 2.5158 + context, 2.5159 + xml, 2.5160 + results, 2.5161 + rsibling.test( selector ) 2.5162 + ); 2.5163 + return results; 2.5164 +} 2.5165 + 2.5166 +if ( document.querySelectorAll ) { 2.5167 + (function() { 2.5168 + var disconnectedMatch, 2.5169 + oldSelect = select, 2.5170 + rescape = /'|\\/g, 2.5171 + rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g, 2.5172 + 2.5173 + // qSa(:focus) reports false when true (Chrome 21), 2.5174 + // A support test would require too much code (would include document ready) 2.5175 + rbuggyQSA = [":focus"], 2.5176 + 2.5177 + // matchesSelector(:focus) reports false when true (Chrome 21), 2.5178 + // matchesSelector(:active) reports false when true (IE9/Opera 11.5) 2.5179 + // A support test would require too much code (would include document ready) 2.5180 + // just skip matchesSelector for :active 2.5181 + rbuggyMatches = [ ":active", ":focus" ], 2.5182 + matches = docElem.matchesSelector || 2.5183 + docElem.mozMatchesSelector || 2.5184 + docElem.webkitMatchesSelector || 2.5185 + docElem.oMatchesSelector || 2.5186 + docElem.msMatchesSelector; 2.5187 + 2.5188 + // Build QSA regex 2.5189 + // Regex strategy adopted from Diego Perini 2.5190 + assert(function( div ) { 2.5191 + // Select is set to empty string on purpose 2.5192 + // This is to test IE's treatment of not explictly 2.5193 + // setting a boolean content attribute, 2.5194 + // since its presence should be enough 2.5195 + // http://bugs.jquery.com/ticket/12359 2.5196 + div.innerHTML = "<select><option selected=''></option></select>"; 2.5197 + 2.5198 + // IE8 - Some boolean attributes are not treated correctly 2.5199 + if ( !div.querySelectorAll("[selected]").length ) { 2.5200 + rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" ); 2.5201 + } 2.5202 + 2.5203 + // Webkit/Opera - :checked should return selected option elements 2.5204 + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 2.5205 + // IE8 throws error here (do not put tests after this one) 2.5206 + if ( !div.querySelectorAll(":checked").length ) { 2.5207 + rbuggyQSA.push(":checked"); 2.5208 + } 2.5209 + }); 2.5210 + 2.5211 + assert(function( div ) { 2.5212 + 2.5213 + // Opera 10-12/IE9 - ^= $= *= and empty values 2.5214 + // Should not select anything 2.5215 + div.innerHTML = "<p test=''></p>"; 2.5216 + if ( div.querySelectorAll("[test^='']").length ) { 2.5217 + rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" ); 2.5218 + } 2.5219 + 2.5220 + // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) 2.5221 + // IE8 throws error here (do not put tests after this one) 2.5222 + div.innerHTML = "<input type='hidden'/>"; 2.5223 + if ( !div.querySelectorAll(":enabled").length ) { 2.5224 + rbuggyQSA.push(":enabled", ":disabled"); 2.5225 + } 2.5226 + }); 2.5227 + 2.5228 + // rbuggyQSA always contains :focus, so no need for a length check 2.5229 + rbuggyQSA = /* rbuggyQSA.length && */ new RegExp( rbuggyQSA.join("|") ); 2.5230 + 2.5231 + select = function( selector, context, results, seed, xml ) { 2.5232 + // Only use querySelectorAll when not filtering, 2.5233 + // when this is not xml, 2.5234 + // and when no QSA bugs apply 2.5235 + if ( !seed && !xml && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { 2.5236 + var groups, i, 2.5237 + old = true, 2.5238 + nid = expando, 2.5239 + newContext = context, 2.5240 + newSelector = context.nodeType === 9 && selector; 2.5241 + 2.5242 + // qSA works strangely on Element-rooted queries 2.5243 + // We can work around this by specifying an extra ID on the root 2.5244 + // and working up from there (Thanks to Andrew Dupont for the technique) 2.5245 + // IE 8 doesn't work on object elements 2.5246 + if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { 2.5247 + groups = tokenize( selector ); 2.5248 + 2.5249 + if ( (old = context.getAttribute("id")) ) { 2.5250 + nid = old.replace( rescape, "\\$&" ); 2.5251 + } else { 2.5252 + context.setAttribute( "id", nid ); 2.5253 + } 2.5254 + nid = "[id='" + nid + "'] "; 2.5255 + 2.5256 + i = groups.length; 2.5257 + while ( i-- ) { 2.5258 + groups[i] = nid + groups[i].join(""); 2.5259 + } 2.5260 + newContext = rsibling.test( selector ) && context.parentNode || context; 2.5261 + newSelector = groups.join(","); 2.5262 + } 2.5263 + 2.5264 + if ( newSelector ) { 2.5265 + try { 2.5266 + push.apply( results, slice.call( newContext.querySelectorAll( 2.5267 + newSelector 2.5268 + ), 0 ) ); 2.5269 + return results; 2.5270 + } catch(qsaError) { 2.5271 + } finally { 2.5272 + if ( !old ) { 2.5273 + context.removeAttribute("id"); 2.5274 + } 2.5275 + } 2.5276 + } 2.5277 + } 2.5278 + 2.5279 + return oldSelect( selector, context, results, seed, xml ); 2.5280 + }; 2.5281 + 2.5282 + if ( matches ) { 2.5283 + assert(function( div ) { 2.5284 + // Check to see if it's possible to do matchesSelector 2.5285 + // on a disconnected node (IE 9) 2.5286 + disconnectedMatch = matches.call( div, "div" ); 2.5287 + 2.5288 + // This should fail with an exception 2.5289 + // Gecko does not error, returns false instead 2.5290 + try { 2.5291 + matches.call( div, "[test!='']:sizzle" ); 2.5292 + rbuggyMatches.push( "!=", pseudos ); 2.5293 + } catch ( e ) {} 2.5294 + }); 2.5295 + 2.5296 + // rbuggyMatches always contains :active and :focus, so no need for a length check 2.5297 + rbuggyMatches = /* rbuggyMatches.length && */ new RegExp( rbuggyMatches.join("|") ); 2.5298 + 2.5299 + Sizzle.matchesSelector = function( elem, expr ) { 2.5300 + // Make sure that attribute selectors are quoted 2.5301 + expr = expr.replace( rattributeQuotes, "='$1']" ); 2.5302 + 2.5303 + // rbuggyMatches always contains :active, so no need for an existence check 2.5304 + if ( !isXML( elem ) && !rbuggyMatches.test( expr ) && (!rbuggyQSA || !rbuggyQSA.test( expr )) ) { 2.5305 + try { 2.5306 + var ret = matches.call( elem, expr ); 2.5307 + 2.5308 + // IE 9's matchesSelector returns false on disconnected nodes 2.5309 + if ( ret || disconnectedMatch || 2.5310 + // As well, disconnected nodes are said to be in a document 2.5311 + // fragment in IE 9 2.5312 + elem.document && elem.document.nodeType !== 11 ) { 2.5313 + return ret; 2.5314 + } 2.5315 + } catch(e) {} 2.5316 + } 2.5317 + 2.5318 + return Sizzle( expr, null, null, [ elem ] ).length > 0; 2.5319 + }; 2.5320 + } 2.5321 + })(); 2.5322 +} 2.5323 + 2.5324 +// Deprecated 2.5325 +Expr.pseudos["nth"] = Expr.pseudos["eq"]; 2.5326 + 2.5327 +// Back-compat 2.5328 +function setFilters() {} 2.5329 +Expr.filters = setFilters.prototype = Expr.pseudos; 2.5330 +Expr.setFilters = new setFilters(); 2.5331 + 2.5332 +// Override sizzle attribute retrieval 2.5333 +Sizzle.attr = jQuery.attr; 2.5334 +jQuery.find = Sizzle; 2.5335 +jQuery.expr = Sizzle.selectors; 2.5336 +jQuery.expr[":"] = jQuery.expr.pseudos; 2.5337 +jQuery.unique = Sizzle.uniqueSort; 2.5338 +jQuery.text = Sizzle.getText; 2.5339 +jQuery.isXMLDoc = Sizzle.isXML; 2.5340 +jQuery.contains = Sizzle.contains; 2.5341 + 2.5342 + 2.5343 +})( window ); 2.5344 +var runtil = /Until$/, 2.5345 + rparentsprev = /^(?:parents|prev(?:Until|All))/, 2.5346 + isSimple = /^.[^:#\[\.,]*$/, 2.5347 + rneedsContext = jQuery.expr.match.needsContext, 2.5348 + // methods guaranteed to produce a unique set when starting from a unique set 2.5349 + guaranteedUnique = { 2.5350 + children: true, 2.5351 + contents: true, 2.5352 + next: true, 2.5353 + prev: true 2.5354 + }; 2.5355 + 2.5356 +jQuery.fn.extend({ 2.5357 + find: function( selector ) { 2.5358 + var i, l, length, n, r, ret, 2.5359 + self = this; 2.5360 + 2.5361 + if ( typeof selector !== "string" ) { 2.5362 + return jQuery( selector ).filter(function() { 2.5363 + for ( i = 0, l = self.length; i < l; i++ ) { 2.5364 + if ( jQuery.contains( self[ i ], this ) ) { 2.5365 + return true; 2.5366 + } 2.5367 + } 2.5368 + }); 2.5369 + } 2.5370 + 2.5371 + ret = this.pushStack( "", "find", selector ); 2.5372 + 2.5373 + for ( i = 0, l = this.length; i < l; i++ ) { 2.5374 + length = ret.length; 2.5375 + jQuery.find( selector, this[i], ret ); 2.5376 + 2.5377 + if ( i > 0 ) { 2.5378 + // Make sure that the results are unique 2.5379 + for ( n = length; n < ret.length; n++ ) { 2.5380 + for ( r = 0; r < length; r++ ) { 2.5381 + if ( ret[r] === ret[n] ) { 2.5382 + ret.splice(n--, 1); 2.5383 + break; 2.5384 + } 2.5385 + } 2.5386 + } 2.5387 + } 2.5388 + } 2.5389 + 2.5390 + return ret; 2.5391 + }, 2.5392 + 2.5393 + has: function( target ) { 2.5394 + var i, 2.5395 + targets = jQuery( target, this ), 2.5396 + len = targets.length; 2.5397 + 2.5398 + return this.filter(function() { 2.5399 + for ( i = 0; i < len; i++ ) { 2.5400 + if ( jQuery.contains( this, targets[i] ) ) { 2.5401 + return true; 2.5402 + } 2.5403 + } 2.5404 + }); 2.5405 + }, 2.5406 + 2.5407 + not: function( selector ) { 2.5408 + return this.pushStack( winnow(this, selector, false), "not", selector); 2.5409 + }, 2.5410 + 2.5411 + filter: function( selector ) { 2.5412 + return this.pushStack( winnow(this, selector, true), "filter", selector ); 2.5413 + }, 2.5414 + 2.5415 + is: function( selector ) { 2.5416 + return !!selector && ( 2.5417 + typeof selector === "string" ? 2.5418 + // If this is a positional/relative selector, check membership in the returned set 2.5419 + // so $("p:first").is("p:last") won't return true for a doc with two "p". 2.5420 + rneedsContext.test( selector ) ? 2.5421 + jQuery( selector, this.context ).index( this[0] ) >= 0 : 2.5422 + jQuery.filter( selector, this ).length > 0 : 2.5423 + this.filter( selector ).length > 0 ); 2.5424 + }, 2.5425 + 2.5426 + closest: function( selectors, context ) { 2.5427 + var cur, 2.5428 + i = 0, 2.5429 + l = this.length, 2.5430 + ret = [], 2.5431 + pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ? 2.5432 + jQuery( selectors, context || this.context ) : 2.5433 + 0; 2.5434 + 2.5435 + for ( ; i < l; i++ ) { 2.5436 + cur = this[i]; 2.5437 + 2.5438 + while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) { 2.5439 + if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) { 2.5440 + ret.push( cur ); 2.5441 + break; 2.5442 + } 2.5443 + cur = cur.parentNode; 2.5444 + } 2.5445 + } 2.5446 + 2.5447 + ret = ret.length > 1 ? jQuery.unique( ret ) : ret; 2.5448 + 2.5449 + return this.pushStack( ret, "closest", selectors ); 2.5450 + }, 2.5451 + 2.5452 + // Determine the position of an element within 2.5453 + // the matched set of elements 2.5454 + index: function( elem ) { 2.5455 + 2.5456 + // No argument, return index in parent 2.5457 + if ( !elem ) { 2.5458 + return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1; 2.5459 + } 2.5460 + 2.5461 + // index in selector 2.5462 + if ( typeof elem === "string" ) { 2.5463 + return jQuery.inArray( this[0], jQuery( elem ) ); 2.5464 + } 2.5465 + 2.5466 + // Locate the position of the desired element 2.5467 + return jQuery.inArray( 2.5468 + // If it receives a jQuery object, the first element is used 2.5469 + elem.jquery ? elem[0] : elem, this ); 2.5470 + }, 2.5471 + 2.5472 + add: function( selector, context ) { 2.5473 + var set = typeof selector === "string" ? 2.5474 + jQuery( selector, context ) : 2.5475 + jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ), 2.5476 + all = jQuery.merge( this.get(), set ); 2.5477 + 2.5478 + return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ? 2.5479 + all : 2.5480 + jQuery.unique( all ) ); 2.5481 + }, 2.5482 + 2.5483 + addBack: function( selector ) { 2.5484 + return this.add( selector == null ? 2.5485 + this.prevObject : this.prevObject.filter(selector) 2.5486 + ); 2.5487 + } 2.5488 +}); 2.5489 + 2.5490 +jQuery.fn.andSelf = jQuery.fn.addBack; 2.5491 + 2.5492 +// A painfully simple check to see if an element is disconnected 2.5493 +// from a document (should be improved, where feasible). 2.5494 +function isDisconnected( node ) { 2.5495 + return !node || !node.parentNode || node.parentNode.nodeType === 11; 2.5496 +} 2.5497 + 2.5498 +function sibling( cur, dir ) { 2.5499 + do { 2.5500 + cur = cur[ dir ]; 2.5501 + } while ( cur && cur.nodeType !== 1 ); 2.5502 + 2.5503 + return cur; 2.5504 +} 2.5505 + 2.5506 +jQuery.each({ 2.5507 + parent: function( elem ) { 2.5508 + var parent = elem.parentNode; 2.5509 + return parent && parent.nodeType !== 11 ? parent : null; 2.5510 + }, 2.5511 + parents: function( elem ) { 2.5512 + return jQuery.dir( elem, "parentNode" ); 2.5513 + }, 2.5514 + parentsUntil: function( elem, i, until ) { 2.5515 + return jQuery.dir( elem, "parentNode", until ); 2.5516 + }, 2.5517 + next: function( elem ) { 2.5518 + return sibling( elem, "nextSibling" ); 2.5519 + }, 2.5520 + prev: function( elem ) { 2.5521 + return sibling( elem, "previousSibling" ); 2.5522 + }, 2.5523 + nextAll: function( elem ) { 2.5524 + return jQuery.dir( elem, "nextSibling" ); 2.5525 + }, 2.5526 + prevAll: function( elem ) { 2.5527 + return jQuery.dir( elem, "previousSibling" ); 2.5528 + }, 2.5529 + nextUntil: function( elem, i, until ) { 2.5530 + return jQuery.dir( elem, "nextSibling", until ); 2.5531 + }, 2.5532 + prevUntil: function( elem, i, until ) { 2.5533 + return jQuery.dir( elem, "previousSibling", until ); 2.5534 + }, 2.5535 + siblings: function( elem ) { 2.5536 + return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem ); 2.5537 + }, 2.5538 + children: function( elem ) { 2.5539 + return jQuery.sibling( elem.firstChild ); 2.5540 + }, 2.5541 + contents: function( elem ) { 2.5542 + return jQuery.nodeName( elem, "iframe" ) ? 2.5543 + elem.contentDocument || elem.contentWindow.document : 2.5544 + jQuery.merge( [], elem.childNodes ); 2.5545 + } 2.5546 +}, function( name, fn ) { 2.5547 + jQuery.fn[ name ] = function( until, selector ) { 2.5548 + var ret = jQuery.map( this, fn, until ); 2.5549 + 2.5550 + if ( !runtil.test( name ) ) { 2.5551 + selector = until; 2.5552 + } 2.5553 + 2.5554 + if ( selector && typeof selector === "string" ) { 2.5555 + ret = jQuery.filter( selector, ret ); 2.5556 + } 2.5557 + 2.5558 + ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret; 2.5559 + 2.5560 + if ( this.length > 1 && rparentsprev.test( name ) ) { 2.5561 + ret = ret.reverse(); 2.5562 + } 2.5563 + 2.5564 + return this.pushStack( ret, name, core_slice.call( arguments ).join(",") ); 2.5565 + }; 2.5566 +}); 2.5567 + 2.5568 +jQuery.extend({ 2.5569 + filter: function( expr, elems, not ) { 2.5570 + if ( not ) { 2.5571 + expr = ":not(" + expr + ")"; 2.5572 + } 2.5573 + 2.5574 + return elems.length === 1 ? 2.5575 + jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] : 2.5576 + jQuery.find.matches(expr, elems); 2.5577 + }, 2.5578 + 2.5579 + dir: function( elem, dir, until ) { 2.5580 + var matched = [], 2.5581 + cur = elem[ dir ]; 2.5582 + 2.5583 + while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) { 2.5584 + if ( cur.nodeType === 1 ) { 2.5585 + matched.push( cur ); 2.5586 + } 2.5587 + cur = cur[dir]; 2.5588 + } 2.5589 + return matched; 2.5590 + }, 2.5591 + 2.5592 + sibling: function( n, elem ) { 2.5593 + var r = []; 2.5594 + 2.5595 + for ( ; n; n = n.nextSibling ) { 2.5596 + if ( n.nodeType === 1 && n !== elem ) { 2.5597 + r.push( n ); 2.5598 + } 2.5599 + } 2.5600 + 2.5601 + return r; 2.5602 + } 2.5603 +}); 2.5604 + 2.5605 +// Implement the identical functionality for filter and not 2.5606 +function winnow( elements, qualifier, keep ) { 2.5607 + 2.5608 + // Can't pass null or undefined to indexOf in Firefox 4 2.5609 + // Set to 0 to skip string check 2.5610 + qualifier = qualifier || 0; 2.5611 + 2.5612 + if ( jQuery.isFunction( qualifier ) ) { 2.5613 + return jQuery.grep(elements, function( elem, i ) { 2.5614 + var retVal = !!qualifier.call( elem, i, elem ); 2.5615 + return retVal === keep; 2.5616 + }); 2.5617 + 2.5618 + } else if ( qualifier.nodeType ) { 2.5619 + return jQuery.grep(elements, function( elem, i ) { 2.5620 + return ( elem === qualifier ) === keep; 2.5621 + }); 2.5622 + 2.5623 + } else if ( typeof qualifier === "string" ) { 2.5624 + var filtered = jQuery.grep(elements, function( elem ) { 2.5625 + return elem.nodeType === 1; 2.5626 + }); 2.5627 + 2.5628 + if ( isSimple.test( qualifier ) ) { 2.5629 + return jQuery.filter(qualifier, filtered, !keep); 2.5630 + } else { 2.5631 + qualifier = jQuery.filter( qualifier, filtered ); 2.5632 + } 2.5633 + } 2.5634 + 2.5635 + return jQuery.grep(elements, function( elem, i ) { 2.5636 + return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep; 2.5637 + }); 2.5638 +} 2.5639 +function createSafeFragment( document ) { 2.5640 + var list = nodeNames.split( "|" ), 2.5641 + safeFrag = document.createDocumentFragment(); 2.5642 + 2.5643 + if ( safeFrag.createElement ) { 2.5644 + while ( list.length ) { 2.5645 + safeFrag.createElement( 2.5646 + list.pop() 2.5647 + ); 2.5648 + } 2.5649 + } 2.5650 + return safeFrag; 2.5651 +} 2.5652 + 2.5653 +var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" + 2.5654 + "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", 2.5655 + rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, 2.5656 + rleadingWhitespace = /^\s+/, 2.5657 + rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, 2.5658 + rtagName = /<([\w:]+)/, 2.5659 + rtbody = /<tbody/i, 2.5660 + rhtml = /<|&#?\w+;/, 2.5661 + rnoInnerhtml = /<(?:script|style|link)/i, 2.5662 + rnocache = /<(?:script|object|embed|option|style)/i, 2.5663 + rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"), 2.5664 + rcheckableType = /^(?:checkbox|radio)$/, 2.5665 + // checked="checked" or checked 2.5666 + rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 2.5667 + rscriptType = /\/(java|ecma)script/i, 2.5668 + rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g, 2.5669 + wrapMap = { 2.5670 + option: [ 1, "<select multiple='multiple'>", "</select>" ], 2.5671 + legend: [ 1, "<fieldset>", "</fieldset>" ], 2.5672 + thead: [ 1, "<table>", "</table>" ], 2.5673 + tr: [ 2, "<table><tbody>", "</tbody></table>" ], 2.5674 + td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], 2.5675 + col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ], 2.5676 + area: [ 1, "<map>", "</map>" ], 2.5677 + _default: [ 0, "", "" ] 2.5678 + }, 2.5679 + safeFragment = createSafeFragment( document ), 2.5680 + fragmentDiv = safeFragment.appendChild( document.createElement("div") ); 2.5681 + 2.5682 +wrapMap.optgroup = wrapMap.option; 2.5683 +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; 2.5684 +wrapMap.th = wrapMap.td; 2.5685 + 2.5686 +// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags, 2.5687 +// unless wrapped in a div with non-breaking characters in front of it. 2.5688 +if ( !jQuery.support.htmlSerialize ) { 2.5689 + wrapMap._default = [ 1, "X<div>", "</div>" ]; 2.5690 +} 2.5691 + 2.5692 +jQuery.fn.extend({ 2.5693 + text: function( value ) { 2.5694 + return jQuery.access( this, function( value ) { 2.5695 + return value === undefined ? 2.5696 + jQuery.text( this ) : 2.5697 + this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) ); 2.5698 + }, null, value, arguments.length ); 2.5699 + }, 2.5700 + 2.5701 + wrapAll: function( html ) { 2.5702 + if ( jQuery.isFunction( html ) ) { 2.5703 + return this.each(function(i) { 2.5704 + jQuery(this).wrapAll( html.call(this, i) ); 2.5705 + }); 2.5706 + } 2.5707 + 2.5708 + if ( this[0] ) { 2.5709 + // The elements to wrap the target around 2.5710 + var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true); 2.5711 + 2.5712 + if ( this[0].parentNode ) { 2.5713 + wrap.insertBefore( this[0] ); 2.5714 + } 2.5715 + 2.5716 + wrap.map(function() { 2.5717 + var elem = this; 2.5718 + 2.5719 + while ( elem.firstChild && elem.firstChild.nodeType === 1 ) { 2.5720 + elem = elem.firstChild; 2.5721 + } 2.5722 + 2.5723 + return elem; 2.5724 + }).append( this ); 2.5725 + } 2.5726 + 2.5727 + return this; 2.5728 + }, 2.5729 + 2.5730 + wrapInner: function( html ) { 2.5731 + if ( jQuery.isFunction( html ) ) { 2.5732 + return this.each(function(i) { 2.5733 + jQuery(this).wrapInner( html.call(this, i) ); 2.5734 + }); 2.5735 + } 2.5736 + 2.5737 + return this.each(function() { 2.5738 + var self = jQuery( this ), 2.5739 + contents = self.contents(); 2.5740 + 2.5741 + if ( contents.length ) { 2.5742 + contents.wrapAll( html ); 2.5743 + 2.5744 + } else { 2.5745 + self.append( html ); 2.5746 + } 2.5747 + }); 2.5748 + }, 2.5749 + 2.5750 + wrap: function( html ) { 2.5751 + var isFunction = jQuery.isFunction( html ); 2.5752 + 2.5753 + return this.each(function(i) { 2.5754 + jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html ); 2.5755 + }); 2.5756 + }, 2.5757 + 2.5758 + unwrap: function() { 2.5759 + return this.parent().each(function() { 2.5760 + if ( !jQuery.nodeName( this, "body" ) ) { 2.5761 + jQuery( this ).replaceWith( this.childNodes ); 2.5762 + } 2.5763 + }).end(); 2.5764 + }, 2.5765 + 2.5766 + append: function() { 2.5767 + return this.domManip(arguments, true, function( elem ) { 2.5768 + if ( this.nodeType === 1 || this.nodeType === 11 ) { 2.5769 + this.appendChild( elem ); 2.5770 + } 2.5771 + }); 2.5772 + }, 2.5773 + 2.5774 + prepend: function() { 2.5775 + return this.domManip(arguments, true, function( elem ) { 2.5776 + if ( this.nodeType === 1 || this.nodeType === 11 ) { 2.5777 + this.insertBefore( elem, this.firstChild ); 2.5778 + } 2.5779 + }); 2.5780 + }, 2.5781 + 2.5782 + before: function() { 2.5783 + if ( !isDisconnected( this[0] ) ) { 2.5784 + return this.domManip(arguments, false, function( elem ) { 2.5785 + this.parentNode.insertBefore( elem, this ); 2.5786 + }); 2.5787 + } 2.5788 + 2.5789 + if ( arguments.length ) { 2.5790 + var set = jQuery.clean( arguments ); 2.5791 + return this.pushStack( jQuery.merge( set, this ), "before", this.selector ); 2.5792 + } 2.5793 + }, 2.5794 + 2.5795 + after: function() { 2.5796 + if ( !isDisconnected( this[0] ) ) { 2.5797 + return this.domManip(arguments, false, function( elem ) { 2.5798 + this.parentNode.insertBefore( elem, this.nextSibling ); 2.5799 + }); 2.5800 + } 2.5801 + 2.5802 + if ( arguments.length ) { 2.5803 + var set = jQuery.clean( arguments ); 2.5804 + return this.pushStack( jQuery.merge( this, set ), "after", this.selector ); 2.5805 + } 2.5806 + }, 2.5807 + 2.5808 + // keepData is for internal use only--do not document 2.5809 + remove: function( selector, keepData ) { 2.5810 + var elem, 2.5811 + i = 0; 2.5812 + 2.5813 + for ( ; (elem = this[i]) != null; i++ ) { 2.5814 + if ( !selector || jQuery.filter( selector, [ elem ] ).length ) { 2.5815 + if ( !keepData && elem.nodeType === 1 ) { 2.5816 + jQuery.cleanData( elem.getElementsByTagName("*") ); 2.5817 + jQuery.cleanData( [ elem ] ); 2.5818 + } 2.5819 + 2.5820 + if ( elem.parentNode ) { 2.5821 + elem.parentNode.removeChild( elem ); 2.5822 + } 2.5823 + } 2.5824 + } 2.5825 + 2.5826 + return this; 2.5827 + }, 2.5828 + 2.5829 + empty: function() { 2.5830 + var elem, 2.5831 + i = 0; 2.5832 + 2.5833 + for ( ; (elem = this[i]) != null; i++ ) { 2.5834 + // Remove element nodes and prevent memory leaks 2.5835 + if ( elem.nodeType === 1 ) { 2.5836 + jQuery.cleanData( elem.getElementsByTagName("*") ); 2.5837 + } 2.5838 + 2.5839 + // Remove any remaining nodes 2.5840 + while ( elem.firstChild ) { 2.5841 + elem.removeChild( elem.firstChild ); 2.5842 + } 2.5843 + } 2.5844 + 2.5845 + return this; 2.5846 + }, 2.5847 + 2.5848 + clone: function( dataAndEvents, deepDataAndEvents ) { 2.5849 + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; 2.5850 + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; 2.5851 + 2.5852 + return this.map( function () { 2.5853 + return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); 2.5854 + }); 2.5855 + }, 2.5856 + 2.5857 + html: function( value ) { 2.5858 + return jQuery.access( this, function( value ) { 2.5859 + var elem = this[0] || {}, 2.5860 + i = 0, 2.5861 + l = this.length; 2.5862 + 2.5863 + if ( value === undefined ) { 2.5864 + return elem.nodeType === 1 ? 2.5865 + elem.innerHTML.replace( rinlinejQuery, "" ) : 2.5866 + undefined; 2.5867 + } 2.5868 + 2.5869 + // See if we can take a shortcut and just use innerHTML 2.5870 + if ( typeof value === "string" && !rnoInnerhtml.test( value ) && 2.5871 + ( jQuery.support.htmlSerialize || !rnoshimcache.test( value ) ) && 2.5872 + ( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) && 2.5873 + !wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) { 2.5874 + 2.5875 + value = value.replace( rxhtmlTag, "<$1></$2>" ); 2.5876 + 2.5877 + try { 2.5878 + for (; i < l; i++ ) { 2.5879 + // Remove element nodes and prevent memory leaks 2.5880 + elem = this[i] || {}; 2.5881 + if ( elem.nodeType === 1 ) { 2.5882 + jQuery.cleanData( elem.getElementsByTagName( "*" ) ); 2.5883 + elem.innerHTML = value; 2.5884 + } 2.5885 + } 2.5886 + 2.5887 + elem = 0; 2.5888 + 2.5889 + // If using innerHTML throws an exception, use the fallback method 2.5890 + } catch(e) {} 2.5891 + } 2.5892 + 2.5893 + if ( elem ) { 2.5894 + this.empty().append( value ); 2.5895 + } 2.5896 + }, null, value, arguments.length ); 2.5897 + }, 2.5898 + 2.5899 + replaceWith: function( value ) { 2.5900 + if ( !isDisconnected( this[0] ) ) { 2.5901 + // Make sure that the elements are removed from the DOM before they are inserted 2.5902 + // this can help fix replacing a parent with child elements 2.5903 + if ( jQuery.isFunction( value ) ) { 2.5904 + return this.each(function(i) { 2.5905 + var self = jQuery(this), old = self.html(); 2.5906 + self.replaceWith( value.call( this, i, old ) ); 2.5907 + }); 2.5908 + } 2.5909 + 2.5910 + if ( typeof value !== "string" ) { 2.5911 + value = jQuery( value ).detach(); 2.5912 + } 2.5913 + 2.5914 + return this.each(function() { 2.5915 + var next = this.nextSibling, 2.5916 + parent = this.parentNode; 2.5917 + 2.5918 + jQuery( this ).remove(); 2.5919 + 2.5920 + if ( next ) { 2.5921 + jQuery(next).before( value ); 2.5922 + } else { 2.5923 + jQuery(parent).append( value ); 2.5924 + } 2.5925 + }); 2.5926 + } 2.5927 + 2.5928 + return this.length ? 2.5929 + this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) : 2.5930 + this; 2.5931 + }, 2.5932 + 2.5933 + detach: function( selector ) { 2.5934 + return this.remove( selector, true ); 2.5935 + }, 2.5936 + 2.5937 + domManip: function( args, table, callback ) { 2.5938 + 2.5939 + // Flatten any nested arrays 2.5940 + args = [].concat.apply( [], args ); 2.5941 + 2.5942 + var results, first, fragment, iNoClone, 2.5943 + i = 0, 2.5944 + value = args[0], 2.5945 + scripts = [], 2.5946 + l = this.length; 2.5947 + 2.5948 + // We can't cloneNode fragments that contain checked, in WebKit 2.5949 + if ( !jQuery.support.checkClone && l > 1 && typeof value === "string" && rchecked.test( value ) ) { 2.5950 + return this.each(function() { 2.5951 + jQuery(this).domManip( args, table, callback ); 2.5952 + }); 2.5953 + } 2.5954 + 2.5955 + if ( jQuery.isFunction(value) ) { 2.5956 + return this.each(function(i) { 2.5957 + var self = jQuery(this); 2.5958 + args[0] = value.call( this, i, table ? self.html() : undefined ); 2.5959 + self.domManip( args, table, callback ); 2.5960 + }); 2.5961 + } 2.5962 + 2.5963 + if ( this[0] ) { 2.5964 + results = jQuery.buildFragment( args, this, scripts ); 2.5965 + fragment = results.fragment; 2.5966 + first = fragment.firstChild; 2.5967 + 2.5968 + if ( fragment.childNodes.length === 1 ) { 2.5969 + fragment = first; 2.5970 + } 2.5971 + 2.5972 + if ( first ) { 2.5973 + table = table && jQuery.nodeName( first, "tr" ); 2.5974 + 2.5975 + // Use the original fragment for the last item instead of the first because it can end up 2.5976 + // being emptied incorrectly in certain situations (#8070). 2.5977 + // Fragments from the fragment cache must always be cloned and never used in place. 2.5978 + for ( iNoClone = results.cacheable || l - 1; i < l; i++ ) { 2.5979 + callback.call( 2.5980 + table && jQuery.nodeName( this[i], "table" ) ? 2.5981 + findOrAppend( this[i], "tbody" ) : 2.5982 + this[i], 2.5983 + i === iNoClone ? 2.5984 + fragment : 2.5985 + jQuery.clone( fragment, true, true ) 2.5986 + ); 2.5987 + } 2.5988 + } 2.5989 + 2.5990 + // Fix #11809: Avoid leaking memory 2.5991 + fragment = first = null; 2.5992 + 2.5993 + if ( scripts.length ) { 2.5994 + jQuery.each( scripts, function( i, elem ) { 2.5995 + if ( elem.src ) { 2.5996 + if ( jQuery.ajax ) { 2.5997 + jQuery.ajax({ 2.5998 + url: elem.src, 2.5999 + type: "GET", 2.6000 + dataType: "script", 2.6001 + async: false, 2.6002 + global: false, 2.6003 + "throws": true 2.6004 + }); 2.6005 + } else { 2.6006 + jQuery.error("no ajax"); 2.6007 + } 2.6008 + } else { 2.6009 + jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "" ) ); 2.6010 + } 2.6011 + 2.6012 + if ( elem.parentNode ) { 2.6013 + elem.parentNode.removeChild( elem ); 2.6014 + } 2.6015 + }); 2.6016 + } 2.6017 + } 2.6018 + 2.6019 + return this; 2.6020 + } 2.6021 +}); 2.6022 + 2.6023 +function findOrAppend( elem, tag ) { 2.6024 + return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) ); 2.6025 +} 2.6026 + 2.6027 +function cloneCopyEvent( src, dest ) { 2.6028 + 2.6029 + if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) { 2.6030 + return; 2.6031 + } 2.6032 + 2.6033 + var type, i, l, 2.6034 + oldData = jQuery._data( src ), 2.6035 + curData = jQuery._data( dest, oldData ), 2.6036 + events = oldData.events; 2.6037 + 2.6038 + if ( events ) { 2.6039 + delete curData.handle; 2.6040 + curData.events = {}; 2.6041 + 2.6042 + for ( type in events ) { 2.6043 + for ( i = 0, l = events[ type ].length; i < l; i++ ) { 2.6044 + jQuery.event.add( dest, type, events[ type ][ i ] ); 2.6045 + } 2.6046 + } 2.6047 + } 2.6048 + 2.6049 + // make the cloned public data object a copy from the original 2.6050 + if ( curData.data ) { 2.6051 + curData.data = jQuery.extend( {}, curData.data ); 2.6052 + } 2.6053 +} 2.6054 + 2.6055 +function cloneFixAttributes( src, dest ) { 2.6056 + var nodeName; 2.6057 + 2.6058 + // We do not need to do anything for non-Elements 2.6059 + if ( dest.nodeType !== 1 ) { 2.6060 + return; 2.6061 + } 2.6062 + 2.6063 + // clearAttributes removes the attributes, which we don't want, 2.6064 + // but also removes the attachEvent events, which we *do* want 2.6065 + if ( dest.clearAttributes ) { 2.6066 + dest.clearAttributes(); 2.6067 + } 2.6068 + 2.6069 + // mergeAttributes, in contrast, only merges back on the 2.6070 + // original attributes, not the events 2.6071 + if ( dest.mergeAttributes ) { 2.6072 + dest.mergeAttributes( src ); 2.6073 + } 2.6074 + 2.6075 + nodeName = dest.nodeName.toLowerCase(); 2.6076 + 2.6077 + if ( nodeName === "object" ) { 2.6078 + // IE6-10 improperly clones children of object elements using classid. 2.6079 + // IE10 throws NoModificationAllowedError if parent is null, #12132. 2.6080 + if ( dest.parentNode ) { 2.6081 + dest.outerHTML = src.outerHTML; 2.6082 + } 2.6083 + 2.6084 + // This path appears unavoidable for IE9. When cloning an object 2.6085 + // element in IE9, the outerHTML strategy above is not sufficient. 2.6086 + // If the src has innerHTML and the destination does not, 2.6087 + // copy the src.innerHTML into the dest.innerHTML. #10324 2.6088 + if ( jQuery.support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML)) ) { 2.6089 + dest.innerHTML = src.innerHTML; 2.6090 + } 2.6091 + 2.6092 + } else if ( nodeName === "input" && rcheckableType.test( src.type ) ) { 2.6093 + // IE6-8 fails to persist the checked state of a cloned checkbox 2.6094 + // or radio button. Worse, IE6-7 fail to give the cloned element 2.6095 + // a checked appearance if the defaultChecked value isn't also set 2.6096 + 2.6097 + dest.defaultChecked = dest.checked = src.checked; 2.6098 + 2.6099 + // IE6-7 get confused and end up setting the value of a cloned 2.6100 + // checkbox/radio button to an empty string instead of "on" 2.6101 + if ( dest.value !== src.value ) { 2.6102 + dest.value = src.value; 2.6103 + } 2.6104 + 2.6105 + // IE6-8 fails to return the selected option to the default selected 2.6106 + // state when cloning options 2.6107 + } else if ( nodeName === "option" ) { 2.6108 + dest.selected = src.defaultSelected; 2.6109 + 2.6110 + // IE6-8 fails to set the defaultValue to the correct value when 2.6111 + // cloning other types of input fields 2.6112 + } else if ( nodeName === "input" || nodeName === "textarea" ) { 2.6113 + dest.defaultValue = src.defaultValue; 2.6114 + 2.6115 + // IE blanks contents when cloning scripts 2.6116 + } else if ( nodeName === "script" && dest.text !== src.text ) { 2.6117 + dest.text = src.text; 2.6118 + } 2.6119 + 2.6120 + // Event data gets referenced instead of copied if the expando 2.6121 + // gets copied too 2.6122 + dest.removeAttribute( jQuery.expando ); 2.6123 +} 2.6124 + 2.6125 +jQuery.buildFragment = function( args, context, scripts ) { 2.6126 + var fragment, cacheable, cachehit, 2.6127 + first = args[ 0 ]; 2.6128 + 2.6129 + // Set context from what may come in as undefined or a jQuery collection or a node 2.6130 + // Updated to fix #12266 where accessing context[0] could throw an exception in IE9/10 & 2.6131 + // also doubles as fix for #8950 where plain objects caused createDocumentFragment exception 2.6132 + context = context || document; 2.6133 + context = !context.nodeType && context[0] || context; 2.6134 + context = context.ownerDocument || context; 2.6135 + 2.6136 + // Only cache "small" (1/2 KB) HTML strings that are associated with the main document 2.6137 + // Cloning options loses the selected state, so don't cache them 2.6138 + // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment 2.6139 + // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache 2.6140 + // Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501 2.6141 + if ( args.length === 1 && typeof first === "string" && first.length < 512 && context === document && 2.6142 + first.charAt(0) === "<" && !rnocache.test( first ) && 2.6143 + (jQuery.support.checkClone || !rchecked.test( first )) && 2.6144 + (jQuery.support.html5Clone || !rnoshimcache.test( first )) ) { 2.6145 + 2.6146 + // Mark cacheable and look for a hit 2.6147 + cacheable = true; 2.6148 + fragment = jQuery.fragments[ first ]; 2.6149 + cachehit = fragment !== undefined; 2.6150 + } 2.6151 + 2.6152 + if ( !fragment ) { 2.6153 + fragment = context.createDocumentFragment(); 2.6154 + jQuery.clean( args, context, fragment, scripts ); 2.6155 + 2.6156 + // Update the cache, but only store false 2.6157 + // unless this is a second parsing of the same content 2.6158 + if ( cacheable ) { 2.6159 + jQuery.fragments[ first ] = cachehit && fragment; 2.6160 + } 2.6161 + } 2.6162 + 2.6163 + return { fragment: fragment, cacheable: cacheable }; 2.6164 +}; 2.6165 + 2.6166 +jQuery.fragments = {}; 2.6167 + 2.6168 +jQuery.each({ 2.6169 + appendTo: "append", 2.6170 + prependTo: "prepend", 2.6171 + insertBefore: "before", 2.6172 + insertAfter: "after", 2.6173 + replaceAll: "replaceWith" 2.6174 +}, function( name, original ) { 2.6175 + jQuery.fn[ name ] = function( selector ) { 2.6176 + var elems, 2.6177 + i = 0, 2.6178 + ret = [], 2.6179 + insert = jQuery( selector ), 2.6180 + l = insert.length, 2.6181 + parent = this.length === 1 && this[0].parentNode; 2.6182 + 2.6183 + if ( (parent == null || parent && parent.nodeType === 11 && parent.childNodes.length === 1) && l === 1 ) { 2.6184 + insert[ original ]( this[0] ); 2.6185 + return this; 2.6186 + } else { 2.6187 + for ( ; i < l; i++ ) { 2.6188 + elems = ( i > 0 ? this.clone(true) : this ).get(); 2.6189 + jQuery( insert[i] )[ original ]( elems ); 2.6190 + ret = ret.concat( elems ); 2.6191 + } 2.6192 + 2.6193 + return this.pushStack( ret, name, insert.selector ); 2.6194 + } 2.6195 + }; 2.6196 +}); 2.6197 + 2.6198 +function getAll( elem ) { 2.6199 + if ( typeof elem.getElementsByTagName !== "undefined" ) { 2.6200 + return elem.getElementsByTagName( "*" ); 2.6201 + 2.6202 + } else if ( typeof elem.querySelectorAll !== "undefined" ) { 2.6203 + return elem.querySelectorAll( "*" ); 2.6204 + 2.6205 + } else { 2.6206 + return []; 2.6207 + } 2.6208 +} 2.6209 + 2.6210 +// Used in clean, fixes the defaultChecked property 2.6211 +function fixDefaultChecked( elem ) { 2.6212 + if ( rcheckableType.test( elem.type ) ) { 2.6213 + elem.defaultChecked = elem.checked; 2.6214 + } 2.6215 +} 2.6216 + 2.6217 +jQuery.extend({ 2.6218 + clone: function( elem, dataAndEvents, deepDataAndEvents ) { 2.6219 + var srcElements, 2.6220 + destElements, 2.6221 + i, 2.6222 + clone; 2.6223 + 2.6224 + if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) { 2.6225 + clone = elem.cloneNode( true ); 2.6226 + 2.6227 + // IE<=8 does not properly clone detached, unknown element nodes 2.6228 + } else { 2.6229 + fragmentDiv.innerHTML = elem.outerHTML; 2.6230 + fragmentDiv.removeChild( clone = fragmentDiv.firstChild ); 2.6231 + } 2.6232 + 2.6233 + if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) && 2.6234 + (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) { 2.6235 + // IE copies events bound via attachEvent when using cloneNode. 2.6236 + // Calling detachEvent on the clone will also remove the events 2.6237 + // from the original. In order to get around this, we use some 2.6238 + // proprietary methods to clear the events. Thanks to MooTools 2.6239 + // guys for this hotness. 2.6240 + 2.6241 + cloneFixAttributes( elem, clone ); 2.6242 + 2.6243 + // Using Sizzle here is crazy slow, so we use getElementsByTagName instead 2.6244 + srcElements = getAll( elem ); 2.6245 + destElements = getAll( clone ); 2.6246 + 2.6247 + // Weird iteration because IE will replace the length property 2.6248 + // with an element if you are cloning the body and one of the 2.6249 + // elements on the page has a name or id of "length" 2.6250 + for ( i = 0; srcElements[i]; ++i ) { 2.6251 + // Ensure that the destination node is not null; Fixes #9587 2.6252 + if ( destElements[i] ) { 2.6253 + cloneFixAttributes( srcElements[i], destElements[i] ); 2.6254 + } 2.6255 + } 2.6256 + } 2.6257 + 2.6258 + // Copy the events from the original to the clone 2.6259 + if ( dataAndEvents ) { 2.6260 + cloneCopyEvent( elem, clone ); 2.6261 + 2.6262 + if ( deepDataAndEvents ) { 2.6263 + srcElements = getAll( elem ); 2.6264 + destElements = getAll( clone ); 2.6265 + 2.6266 + for ( i = 0; srcElements[i]; ++i ) { 2.6267 + cloneCopyEvent( srcElements[i], destElements[i] ); 2.6268 + } 2.6269 + } 2.6270 + } 2.6271 + 2.6272 + srcElements = destElements = null; 2.6273 + 2.6274 + // Return the cloned set 2.6275 + return clone; 2.6276 + }, 2.6277 + 2.6278 + clean: function( elems, context, fragment, scripts ) { 2.6279 + var i, j, elem, tag, wrap, depth, div, hasBody, tbody, len, handleScript, jsTags, 2.6280 + safe = context === document && safeFragment, 2.6281 + ret = []; 2.6282 + 2.6283 + // Ensure that context is a document 2.6284 + if ( !context || typeof context.createDocumentFragment === "undefined" ) { 2.6285 + context = document; 2.6286 + } 2.6287 + 2.6288 + // Use the already-created safe fragment if context permits 2.6289 + for ( i = 0; (elem = elems[i]) != null; i++ ) { 2.6290 + if ( typeof elem === "number" ) { 2.6291 + elem += ""; 2.6292 + } 2.6293 + 2.6294 + if ( !elem ) { 2.6295 + continue; 2.6296 + } 2.6297 + 2.6298 + // Convert html string into DOM nodes 2.6299 + if ( typeof elem === "string" ) { 2.6300 + if ( !rhtml.test( elem ) ) { 2.6301 + elem = context.createTextNode( elem ); 2.6302 + } else { 2.6303 + // Ensure a safe container in which to render the html 2.6304 + safe = safe || createSafeFragment( context ); 2.6305 + div = context.createElement("div"); 2.6306 + safe.appendChild( div ); 2.6307 + 2.6308 + // Fix "XHTML"-style tags in all browsers 2.6309 + elem = elem.replace(rxhtmlTag, "<$1></$2>"); 2.6310 + 2.6311 + // Go to html and back, then peel off extra wrappers 2.6312 + tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(); 2.6313 + wrap = wrapMap[ tag ] || wrapMap._default; 2.6314 + depth = wrap[0]; 2.6315 + div.innerHTML = wrap[1] + elem + wrap[2]; 2.6316 + 2.6317 + // Move to the right depth 2.6318 + while ( depth-- ) { 2.6319 + div = div.lastChild; 2.6320 + } 2.6321 + 2.6322 + // Remove IE's autoinserted <tbody> from table fragments 2.6323 + if ( !jQuery.support.tbody ) { 2.6324 + 2.6325 + // String was a <table>, *may* have spurious <tbody> 2.6326 + hasBody = rtbody.test(elem); 2.6327 + tbody = tag === "table" && !hasBody ? 2.6328 + div.firstChild && div.firstChild.childNodes : 2.6329 + 2.6330 + // String was a bare <thead> or <tfoot> 2.6331 + wrap[1] === "<table>" && !hasBody ? 2.6332 + div.childNodes : 2.6333 + []; 2.6334 + 2.6335 + for ( j = tbody.length - 1; j >= 0 ; --j ) { 2.6336 + if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) { 2.6337 + tbody[ j ].parentNode.removeChild( tbody[ j ] ); 2.6338 + } 2.6339 + } 2.6340 + } 2.6341 + 2.6342 + // IE completely kills leading whitespace when innerHTML is used 2.6343 + if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) { 2.6344 + div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild ); 2.6345 + } 2.6346 + 2.6347 + elem = div.childNodes; 2.6348 + 2.6349 + // Take out of fragment container (we need a fresh div each time) 2.6350 + div.parentNode.removeChild( div ); 2.6351 + } 2.6352 + } 2.6353 + 2.6354 + if ( elem.nodeType ) { 2.6355 + ret.push( elem ); 2.6356 + } else { 2.6357 + jQuery.merge( ret, elem ); 2.6358 + } 2.6359 + } 2.6360 + 2.6361 + // Fix #11356: Clear elements from safeFragment 2.6362 + if ( div ) { 2.6363 + elem = div = safe = null; 2.6364 + } 2.6365 + 2.6366 + // Reset defaultChecked for any radios and checkboxes 2.6367 + // about to be appended to the DOM in IE 6/7 (#8060) 2.6368 + if ( !jQuery.support.appendChecked ) { 2.6369 + for ( i = 0; (elem = ret[i]) != null; i++ ) { 2.6370 + if ( jQuery.nodeName( elem, "input" ) ) { 2.6371 + fixDefaultChecked( elem ); 2.6372 + } else if ( typeof elem.getElementsByTagName !== "undefined" ) { 2.6373 + jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked ); 2.6374 + } 2.6375 + } 2.6376 + } 2.6377 + 2.6378 + // Append elements to a provided document fragment 2.6379 + if ( fragment ) { 2.6380 + // Special handling of each script element 2.6381 + handleScript = function( elem ) { 2.6382 + // Check if we consider it executable 2.6383 + if ( !elem.type || rscriptType.test( elem.type ) ) { 2.6384 + // Detach the script and store it in the scripts array (if provided) or the fragment 2.6385 + // Return truthy to indicate that it has been handled 2.6386 + return scripts ? 2.6387 + scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) : 2.6388 + fragment.appendChild( elem ); 2.6389 + } 2.6390 + }; 2.6391 + 2.6392 + for ( i = 0; (elem = ret[i]) != null; i++ ) { 2.6393 + // Check if we're done after handling an executable script 2.6394 + if ( !( jQuery.nodeName( elem, "script" ) && handleScript( elem ) ) ) { 2.6395 + // Append to fragment and handle embedded scripts 2.6396 + fragment.appendChild( elem ); 2.6397 + if ( typeof elem.getElementsByTagName !== "undefined" ) { 2.6398 + // handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration 2.6399 + jsTags = jQuery.grep( jQuery.merge( [], elem.getElementsByTagName("script") ), handleScript ); 2.6400 + 2.6401 + // Splice the scripts into ret after their former ancestor and advance our index beyond them 2.6402 + ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) ); 2.6403 + i += jsTags.length; 2.6404 + } 2.6405 + } 2.6406 + } 2.6407 + } 2.6408 + 2.6409 + return ret; 2.6410 + }, 2.6411 + 2.6412 + cleanData: function( elems, /* internal */ acceptData ) { 2.6413 + var data, id, elem, type, 2.6414 + i = 0, 2.6415 + internalKey = jQuery.expando, 2.6416 + cache = jQuery.cache, 2.6417 + deleteExpando = jQuery.support.deleteExpando, 2.6418 + special = jQuery.event.special; 2.6419 + 2.6420 + for ( ; (elem = elems[i]) != null; i++ ) { 2.6421 + 2.6422 + if ( acceptData || jQuery.acceptData( elem ) ) { 2.6423 + 2.6424 + id = elem[ internalKey ]; 2.6425 + data = id && cache[ id ]; 2.6426 + 2.6427 + if ( data ) { 2.6428 + if ( data.events ) { 2.6429 + for ( type in data.events ) { 2.6430 + if ( special[ type ] ) { 2.6431 + jQuery.event.remove( elem, type ); 2.6432 + 2.6433 + // This is a shortcut to avoid jQuery.event.remove's overhead 2.6434 + } else { 2.6435 + jQuery.removeEvent( elem, type, data.handle ); 2.6436 + } 2.6437 + } 2.6438 + } 2.6439 + 2.6440 + // Remove cache only if it was not already removed by jQuery.event.remove 2.6441 + if ( cache[ id ] ) { 2.6442 + 2.6443 + delete cache[ id ]; 2.6444 + 2.6445 + // IE does not allow us to delete expando properties from nodes, 2.6446 + // nor does it have a removeAttribute function on Document nodes; 2.6447 + // we must handle all of these cases 2.6448 + if ( deleteExpando ) { 2.6449 + delete elem[ internalKey ]; 2.6450 + 2.6451 + } else if ( elem.removeAttribute ) { 2.6452 + elem.removeAttribute( internalKey ); 2.6453 + 2.6454 + } else { 2.6455 + elem[ internalKey ] = null; 2.6456 + } 2.6457 + 2.6458 + jQuery.deletedIds.push( id ); 2.6459 + } 2.6460 + } 2.6461 + } 2.6462 + } 2.6463 + } 2.6464 +}); 2.6465 +// Limit scope pollution from any deprecated API 2.6466 +(function() { 2.6467 + 2.6468 +var matched, browser; 2.6469 + 2.6470 +// Use of jQuery.browser is frowned upon. 2.6471 +// More details: http://api.jquery.com/jQuery.browser 2.6472 +// jQuery.uaMatch maintained for back-compat 2.6473 +jQuery.uaMatch = function( ua ) { 2.6474 + ua = ua.toLowerCase(); 2.6475 + 2.6476 + var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) || 2.6477 + /(webkit)[ \/]([\w.]+)/.exec( ua ) || 2.6478 + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) || 2.6479 + /(msie) ([\w.]+)/.exec( ua ) || 2.6480 + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) || 2.6481 + []; 2.6482 + 2.6483 + return { 2.6484 + browser: match[ 1 ] || "", 2.6485 + version: match[ 2 ] || "0" 2.6486 + }; 2.6487 +}; 2.6488 + 2.6489 +matched = jQuery.uaMatch( navigator.userAgent ); 2.6490 +browser = {}; 2.6491 + 2.6492 +if ( matched.browser ) { 2.6493 + browser[ matched.browser ] = true; 2.6494 + browser.version = matched.version; 2.6495 +} 2.6496 + 2.6497 +// Chrome is Webkit, but Webkit is also Safari. 2.6498 +if ( browser.chrome ) { 2.6499 + browser.webkit = true; 2.6500 +} else if ( browser.webkit ) { 2.6501 + browser.safari = true; 2.6502 +} 2.6503 + 2.6504 +jQuery.browser = browser; 2.6505 + 2.6506 +jQuery.sub = function() { 2.6507 + function jQuerySub( selector, context ) { 2.6508 + return new jQuerySub.fn.init( selector, context ); 2.6509 + } 2.6510 + jQuery.extend( true, jQuerySub, this ); 2.6511 + jQuerySub.superclass = this; 2.6512 + jQuerySub.fn = jQuerySub.prototype = this(); 2.6513 + jQuerySub.fn.constructor = jQuerySub; 2.6514 + jQuerySub.sub = this.sub; 2.6515 + jQuerySub.fn.init = function init( selector, context ) { 2.6516 + if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) { 2.6517 + context = jQuerySub( context ); 2.6518 + } 2.6519 + 2.6520 + return jQuery.fn.init.call( this, selector, context, rootjQuerySub ); 2.6521 + }; 2.6522 + jQuerySub.fn.init.prototype = jQuerySub.fn; 2.6523 + var rootjQuerySub = jQuerySub(document); 2.6524 + return jQuerySub; 2.6525 +}; 2.6526 + 2.6527 +})(); 2.6528 +var curCSS, iframe, iframeDoc, 2.6529 + ralpha = /alpha\([^)]*\)/i, 2.6530 + ropacity = /opacity=([^)]*)/, 2.6531 + rposition = /^(top|right|bottom|left)$/, 2.6532 + // swappable if display is none or starts with table except "table", "table-cell", or "table-caption" 2.6533 + // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display 2.6534 + rdisplayswap = /^(none|table(?!-c[ea]).+)/, 2.6535 + rmargin = /^margin/, 2.6536 + rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ), 2.6537 + rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ), 2.6538 + rrelNum = new RegExp( "^([-+])=(" + core_pnum + ")", "i" ), 2.6539 + elemdisplay = {}, 2.6540 + 2.6541 + cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 2.6542 + cssNormalTransform = { 2.6543 + letterSpacing: 0, 2.6544 + fontWeight: 400 2.6545 + }, 2.6546 + 2.6547 + cssExpand = [ "Top", "Right", "Bottom", "Left" ], 2.6548 + cssPrefixes = [ "Webkit", "O", "Moz", "ms" ], 2.6549 + 2.6550 + eventsToggle = jQuery.fn.toggle; 2.6551 + 2.6552 +// return a css property mapped to a potentially vendor prefixed property 2.6553 +function vendorPropName( style, name ) { 2.6554 + 2.6555 + // shortcut for names that are not vendor prefixed 2.6556 + if ( name in style ) { 2.6557 + return name; 2.6558 + } 2.6559 + 2.6560 + // check for vendor prefixed names 2.6561 + var capName = name.charAt(0).toUpperCase() + name.slice(1), 2.6562 + origName = name, 2.6563 + i = cssPrefixes.length; 2.6564 + 2.6565 + while ( i-- ) { 2.6566 + name = cssPrefixes[ i ] + capName; 2.6567 + if ( name in style ) { 2.6568 + return name; 2.6569 + } 2.6570 + } 2.6571 + 2.6572 + return origName; 2.6573 +} 2.6574 + 2.6575 +function isHidden( elem, el ) { 2.6576 + elem = el || elem; 2.6577 + return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem ); 2.6578 +} 2.6579 + 2.6580 +function showHide( elements, show ) { 2.6581 + var elem, display, 2.6582 + values = [], 2.6583 + index = 0, 2.6584 + length = elements.length; 2.6585 + 2.6586 + for ( ; index < length; index++ ) { 2.6587 + elem = elements[ index ]; 2.6588 + if ( !elem.style ) { 2.6589 + continue; 2.6590 + } 2.6591 + values[ index ] = jQuery._data( elem, "olddisplay" ); 2.6592 + if ( show ) { 2.6593 + // Reset the inline display of this element to learn if it is 2.6594 + // being hidden by cascaded rules or not 2.6595 + if ( !values[ index ] && elem.style.display === "none" ) { 2.6596 + elem.style.display = ""; 2.6597 + } 2.6598 + 2.6599 + // Set elements which have been overridden with display: none 2.6600 + // in a stylesheet to whatever the default browser style is 2.6601 + // for such an element 2.6602 + if ( elem.style.display === "" && isHidden( elem ) ) { 2.6603 + values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) ); 2.6604 + } 2.6605 + } else { 2.6606 + display = curCSS( elem, "display" ); 2.6607 + 2.6608 + if ( !values[ index ] && display !== "none" ) { 2.6609 + jQuery._data( elem, "olddisplay", display ); 2.6610 + } 2.6611 + } 2.6612 + } 2.6613 + 2.6614 + // Set the display of most of the elements in a second loop 2.6615 + // to avoid the constant reflow 2.6616 + for ( index = 0; index < length; index++ ) { 2.6617 + elem = elements[ index ]; 2.6618 + if ( !elem.style ) { 2.6619 + continue; 2.6620 + } 2.6621 + if ( !show || elem.style.display === "none" || elem.style.display === "" ) { 2.6622 + elem.style.display = show ? values[ index ] || "" : "none"; 2.6623 + } 2.6624 + } 2.6625 + 2.6626 + return elements; 2.6627 +} 2.6628 + 2.6629 +jQuery.fn.extend({ 2.6630 + css: function( name, value ) { 2.6631 + return jQuery.access( this, function( elem, name, value ) { 2.6632 + return value !== undefined ? 2.6633 + jQuery.style( elem, name, value ) : 2.6634 + jQuery.css( elem, name ); 2.6635 + }, name, value, arguments.length > 1 ); 2.6636 + }, 2.6637 + show: function() { 2.6638 + return showHide( this, true ); 2.6639 + }, 2.6640 + hide: function() { 2.6641 + return showHide( this ); 2.6642 + }, 2.6643 + toggle: function( state, fn2 ) { 2.6644 + var bool = typeof state === "boolean"; 2.6645 + 2.6646 + if ( jQuery.isFunction( state ) && jQuery.isFunction( fn2 ) ) { 2.6647 + return eventsToggle.apply( this, arguments ); 2.6648 + } 2.6649 + 2.6650 + return this.each(function() { 2.6651 + if ( bool ? state : isHidden( this ) ) { 2.6652 + jQuery( this ).show(); 2.6653 + } else { 2.6654 + jQuery( this ).hide(); 2.6655 + } 2.6656 + }); 2.6657 + } 2.6658 +}); 2.6659 + 2.6660 +jQuery.extend({ 2.6661 + // Add in style property hooks for overriding the default 2.6662 + // behavior of getting and setting a style property 2.6663 + cssHooks: { 2.6664 + opacity: { 2.6665 + get: function( elem, computed ) { 2.6666 + if ( computed ) { 2.6667 + // We should always get a number back from opacity 2.6668 + var ret = curCSS( elem, "opacity" ); 2.6669 + return ret === "" ? "1" : ret; 2.6670 + 2.6671 + } 2.6672 + } 2.6673 + } 2.6674 + }, 2.6675 + 2.6676 + // Exclude the following css properties to add px 2.6677 + cssNumber: { 2.6678 + "fillOpacity": true, 2.6679 + "fontWeight": true, 2.6680 + "lineHeight": true, 2.6681 + "opacity": true, 2.6682 + "orphans": true, 2.6683 + "widows": true, 2.6684 + "zIndex": true, 2.6685 + "zoom": true 2.6686 + }, 2.6687 + 2.6688 + // Add in properties whose names you wish to fix before 2.6689 + // setting or getting the value 2.6690 + cssProps: { 2.6691 + // normalize float css property 2.6692 + "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat" 2.6693 + }, 2.6694 + 2.6695 + // Get and set the style property on a DOM Node 2.6696 + style: function( elem, name, value, extra ) { 2.6697 + // Don't set styles on text and comment nodes 2.6698 + if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { 2.6699 + return; 2.6700 + } 2.6701 + 2.6702 + // Make sure that we're working with the right name 2.6703 + var ret, type, hooks, 2.6704 + origName = jQuery.camelCase( name ), 2.6705 + style = elem.style; 2.6706 + 2.6707 + name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) ); 2.6708 + 2.6709 + // gets hook for the prefixed version 2.6710 + // followed by the unprefixed version 2.6711 + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 2.6712 + 2.6713 + // Check if we're setting a value 2.6714 + if ( value !== undefined ) { 2.6715 + type = typeof value; 2.6716 + 2.6717 + // convert relative number strings (+= or -=) to relative numbers. #7345 2.6718 + if ( type === "string" && (ret = rrelNum.exec( value )) ) { 2.6719 + value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) ); 2.6720 + // Fixes bug #9237 2.6721 + type = "number"; 2.6722 + } 2.6723 + 2.6724 + // Make sure that NaN and null values aren't set. See: #7116 2.6725 + if ( value == null || type === "number" && isNaN( value ) ) { 2.6726 + return; 2.6727 + } 2.6728 + 2.6729 + // If a number was passed in, add 'px' to the (except for certain CSS properties) 2.6730 + if ( type === "number" && !jQuery.cssNumber[ origName ] ) { 2.6731 + value += "px"; 2.6732 + } 2.6733 + 2.6734 + // If a hook was provided, use that value, otherwise just set the specified value 2.6735 + if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) { 2.6736 + // Wrapped to prevent IE from throwing errors when 'invalid' values are provided 2.6737 + // Fixes bug #5509 2.6738 + try { 2.6739 + style[ name ] = value; 2.6740 + } catch(e) {} 2.6741 + } 2.6742 + 2.6743 + } else { 2.6744 + // If a hook was provided get the non-computed value from there 2.6745 + if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) { 2.6746 + return ret; 2.6747 + } 2.6748 + 2.6749 + // Otherwise just get the value from the style object 2.6750 + return style[ name ]; 2.6751 + } 2.6752 + }, 2.6753 + 2.6754 + css: function( elem, name, numeric, extra ) { 2.6755 + var val, num, hooks, 2.6756 + origName = jQuery.camelCase( name ); 2.6757 + 2.6758 + // Make sure that we're working with the right name 2.6759 + name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) ); 2.6760 + 2.6761 + // gets hook for the prefixed version 2.6762 + // followed by the unprefixed version 2.6763 + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 2.6764 + 2.6765 + // If a hook was provided get the computed value from there 2.6766 + if ( hooks && "get" in hooks ) { 2.6767 + val = hooks.get( elem, true, extra ); 2.6768 + } 2.6769 + 2.6770 + // Otherwise, if a way to get the computed value exists, use that 2.6771 + if ( val === undefined ) { 2.6772 + val = curCSS( elem, name ); 2.6773 + } 2.6774 + 2.6775 + //convert "normal" to computed value 2.6776 + if ( val === "normal" && name in cssNormalTransform ) { 2.6777 + val = cssNormalTransform[ name ]; 2.6778 + } 2.6779 + 2.6780 + // Return, converting to number if forced or a qualifier was provided and val looks numeric 2.6781 + if ( numeric || extra !== undefined ) { 2.6782 + num = parseFloat( val ); 2.6783 + return numeric || jQuery.isNumeric( num ) ? num || 0 : val; 2.6784 + } 2.6785 + return val; 2.6786 + }, 2.6787 + 2.6788 + // A method for quickly swapping in/out CSS properties to get correct calculations 2.6789 + swap: function( elem, options, callback ) { 2.6790 + var ret, name, 2.6791 + old = {}; 2.6792 + 2.6793 + // Remember the old values, and insert the new ones 2.6794 + for ( name in options ) { 2.6795 + old[ name ] = elem.style[ name ]; 2.6796 + elem.style[ name ] = options[ name ]; 2.6797 + } 2.6798 + 2.6799 + ret = callback.call( elem ); 2.6800 + 2.6801 + // Revert the old values 2.6802 + for ( name in options ) { 2.6803 + elem.style[ name ] = old[ name ]; 2.6804 + } 2.6805 + 2.6806 + return ret; 2.6807 + } 2.6808 +}); 2.6809 + 2.6810 +// NOTE: To any future maintainer, we've window.getComputedStyle 2.6811 +// because jsdom on node.js will break without it. 2.6812 +if ( window.getComputedStyle ) { 2.6813 + curCSS = function( elem, name ) { 2.6814 + var ret, width, minWidth, maxWidth, 2.6815 + computed = window.getComputedStyle( elem, null ), 2.6816 + style = elem.style; 2.6817 + 2.6818 + if ( computed ) { 2.6819 + 2.6820 + ret = computed[ name ]; 2.6821 + if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) { 2.6822 + ret = jQuery.style( elem, name ); 2.6823 + } 2.6824 + 2.6825 + // A tribute to the "awesome hack by Dean Edwards" 2.6826 + // Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right 2.6827 + // Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels 2.6828 + // this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values 2.6829 + if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) { 2.6830 + width = style.width; 2.6831 + minWidth = style.minWidth; 2.6832 + maxWidth = style.maxWidth; 2.6833 + 2.6834 + style.minWidth = style.maxWidth = style.width = ret; 2.6835 + ret = computed.width; 2.6836 + 2.6837 + style.width = width; 2.6838 + style.minWidth = minWidth; 2.6839 + style.maxWidth = maxWidth; 2.6840 + } 2.6841 + } 2.6842 + 2.6843 + return ret; 2.6844 + }; 2.6845 +} else if ( document.documentElement.currentStyle ) { 2.6846 + curCSS = function( elem, name ) { 2.6847 + var left, rsLeft, 2.6848 + ret = elem.currentStyle && elem.currentStyle[ name ], 2.6849 + style = elem.style; 2.6850 + 2.6851 + // Avoid setting ret to empty string here 2.6852 + // so we don't default to auto 2.6853 + if ( ret == null && style && style[ name ] ) { 2.6854 + ret = style[ name ]; 2.6855 + } 2.6856 + 2.6857 + // From the awesome hack by Dean Edwards 2.6858 + // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 2.6859 + 2.6860 + // If we're not dealing with a regular pixel number 2.6861 + // but a number that has a weird ending, we need to convert it to pixels 2.6862 + // but not position css attributes, as those are proportional to the parent element instead 2.6863 + // and we can't measure the parent instead because it might trigger a "stacking dolls" problem 2.6864 + if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) { 2.6865 + 2.6866 + // Remember the original values 2.6867 + left = style.left; 2.6868 + rsLeft = elem.runtimeStyle && elem.runtimeStyle.left; 2.6869 + 2.6870 + // Put in the new values to get a computed value out 2.6871 + if ( rsLeft ) { 2.6872 + elem.runtimeStyle.left = elem.currentStyle.left; 2.6873 + } 2.6874 + style.left = name === "fontSize" ? "1em" : ret; 2.6875 + ret = style.pixelLeft + "px"; 2.6876 + 2.6877 + // Revert the changed values 2.6878 + style.left = left; 2.6879 + if ( rsLeft ) { 2.6880 + elem.runtimeStyle.left = rsLeft; 2.6881 + } 2.6882 + } 2.6883 + 2.6884 + return ret === "" ? "auto" : ret; 2.6885 + }; 2.6886 +} 2.6887 + 2.6888 +function setPositiveNumber( elem, value, subtract ) { 2.6889 + var matches = rnumsplit.exec( value ); 2.6890 + return matches ? 2.6891 + Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) : 2.6892 + value; 2.6893 +} 2.6894 + 2.6895 +function augmentWidthOrHeight( elem, name, extra, isBorderBox ) { 2.6896 + var i = extra === ( isBorderBox ? "border" : "content" ) ? 2.6897 + // If we already have the right measurement, avoid augmentation 2.6898 + 4 : 2.6899 + // Otherwise initialize for horizontal or vertical properties 2.6900 + name === "width" ? 1 : 0, 2.6901 + 2.6902 + val = 0; 2.6903 + 2.6904 + for ( ; i < 4; i += 2 ) { 2.6905 + // both box models exclude margin, so add it if we want it 2.6906 + if ( extra === "margin" ) { 2.6907 + // we use jQuery.css instead of curCSS here 2.6908 + // because of the reliableMarginRight CSS hook! 2.6909 + val += jQuery.css( elem, extra + cssExpand[ i ], true ); 2.6910 + } 2.6911 + 2.6912 + // From this point on we use curCSS for maximum performance (relevant in animations) 2.6913 + if ( isBorderBox ) { 2.6914 + // border-box includes padding, so remove it if we want content 2.6915 + if ( extra === "content" ) { 2.6916 + val -= parseFloat( curCSS( elem, "padding" + cssExpand[ i ] ) ) || 0; 2.6917 + } 2.6918 + 2.6919 + // at this point, extra isn't border nor margin, so remove border 2.6920 + if ( extra !== "margin" ) { 2.6921 + val -= parseFloat( curCSS( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0; 2.6922 + } 2.6923 + } else { 2.6924 + // at this point, extra isn't content, so add padding 2.6925 + val += parseFloat( curCSS( elem, "padding" + cssExpand[ i ] ) ) || 0; 2.6926 + 2.6927 + // at this point, extra isn't content nor padding, so add border 2.6928 + if ( extra !== "padding" ) { 2.6929 + val += parseFloat( curCSS( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0; 2.6930 + } 2.6931 + } 2.6932 + } 2.6933 + 2.6934 + return val; 2.6935 +} 2.6936 + 2.6937 +function getWidthOrHeight( elem, name, extra ) { 2.6938 + 2.6939 + // Start with offset property, which is equivalent to the border-box value 2.6940 + var val = name === "width" ? elem.offsetWidth : elem.offsetHeight, 2.6941 + valueIsBorderBox = true, 2.6942 + isBorderBox = jQuery.support.boxSizing && jQuery.css( elem, "boxSizing" ) === "border-box"; 2.6943 + 2.6944 + // some non-html elements return undefined for offsetWidth, so check for null/undefined 2.6945 + // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285 2.6946 + // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668 2.6947 + if ( val <= 0 || val == null ) { 2.6948 + // Fall back to computed then uncomputed css if necessary 2.6949 + val = curCSS( elem, name ); 2.6950 + if ( val < 0 || val == null ) { 2.6951 + val = elem.style[ name ]; 2.6952 + } 2.6953 + 2.6954 + // Computed unit is not pixels. Stop here and return. 2.6955 + if ( rnumnonpx.test(val) ) { 2.6956 + return val; 2.6957 + } 2.6958 + 2.6959 + // we need the check for style in case a browser which returns unreliable values 2.6960 + // for getComputedStyle silently falls back to the reliable elem.style 2.6961 + valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] ); 2.6962 + 2.6963 + // Normalize "", auto, and prepare for extra 2.6964 + val = parseFloat( val ) || 0; 2.6965 + } 2.6966 + 2.6967 + // use the active box-sizing model to add/subtract irrelevant styles 2.6968 + return ( val + 2.6969 + augmentWidthOrHeight( 2.6970 + elem, 2.6971 + name, 2.6972 + extra || ( isBorderBox ? "border" : "content" ), 2.6973 + valueIsBorderBox 2.6974 + ) 2.6975 + ) + "px"; 2.6976 +} 2.6977 + 2.6978 + 2.6979 +// Try to determine the default display value of an element 2.6980 +function css_defaultDisplay( nodeName ) { 2.6981 + if ( elemdisplay[ nodeName ] ) { 2.6982 + return elemdisplay[ nodeName ]; 2.6983 + } 2.6984 + 2.6985 + var elem = jQuery( "<" + nodeName + ">" ).appendTo( document.body ), 2.6986 + display = elem.css("display"); 2.6987 + elem.remove(); 2.6988 + 2.6989 + // If the simple way fails, 2.6990 + // get element's real default display by attaching it to a temp iframe 2.6991 + if ( display === "none" || display === "" ) { 2.6992 + // Use the already-created iframe if possible 2.6993 + iframe = document.body.appendChild( 2.6994 + iframe || jQuery.extend( document.createElement("iframe"), { 2.6995 + frameBorder: 0, 2.6996 + width: 0, 2.6997 + height: 0 2.6998 + }) 2.6999 + ); 2.7000 + 2.7001 + // Create a cacheable copy of the iframe document on first call. 2.7002 + // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML 2.7003 + // document to it; WebKit & Firefox won't allow reusing the iframe document. 2.7004 + if ( !iframeDoc || !iframe.createElement ) { 2.7005 + iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document; 2.7006 + iframeDoc.write("<!doctype html><html><body>"); 2.7007 + iframeDoc.close(); 2.7008 + } 2.7009 + 2.7010 + elem = iframeDoc.body.appendChild( iframeDoc.createElement(nodeName) ); 2.7011 + 2.7012 + display = curCSS( elem, "display" ); 2.7013 + document.body.removeChild( iframe ); 2.7014 + } 2.7015 + 2.7016 + // Store the correct default display 2.7017 + elemdisplay[ nodeName ] = display; 2.7018 + 2.7019 + return display; 2.7020 +} 2.7021 + 2.7022 +jQuery.each([ "height", "width" ], function( i, name ) { 2.7023 + jQuery.cssHooks[ name ] = { 2.7024 + get: function( elem, computed, extra ) { 2.7025 + if ( computed ) { 2.7026 + // certain elements can have dimension info if we invisibly show them 2.7027 + // however, it must have a current display style that would benefit from this 2.7028 + if ( elem.offsetWidth === 0 && rdisplayswap.test( curCSS( elem, "display" ) ) ) { 2.7029 + return jQuery.swap( elem, cssShow, function() { 2.7030 + return getWidthOrHeight( elem, name, extra ); 2.7031 + }); 2.7032 + } else { 2.7033 + return getWidthOrHeight( elem, name, extra ); 2.7034 + } 2.7035 + } 2.7036 + }, 2.7037 + 2.7038 + set: function( elem, value, extra ) { 2.7039 + return setPositiveNumber( elem, value, extra ? 2.7040 + augmentWidthOrHeight( 2.7041 + elem, 2.7042 + name, 2.7043 + extra, 2.7044 + jQuery.support.boxSizing && jQuery.css( elem, "boxSizing" ) === "border-box" 2.7045 + ) : 0 2.7046 + ); 2.7047 + } 2.7048 + }; 2.7049 +}); 2.7050 + 2.7051 +if ( !jQuery.support.opacity ) { 2.7052 + jQuery.cssHooks.opacity = { 2.7053 + get: function( elem, computed ) { 2.7054 + // IE uses filters for opacity 2.7055 + return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ? 2.7056 + ( 0.01 * parseFloat( RegExp.$1 ) ) + "" : 2.7057 + computed ? "1" : ""; 2.7058 + }, 2.7059 + 2.7060 + set: function( elem, value ) { 2.7061 + var style = elem.style, 2.7062 + currentStyle = elem.currentStyle, 2.7063 + opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "", 2.7064 + filter = currentStyle && currentStyle.filter || style.filter || ""; 2.7065 + 2.7066 + // IE has trouble with opacity if it does not have layout 2.7067 + // Force it by setting the zoom level 2.7068 + style.zoom = 1; 2.7069 + 2.7070 + // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652 2.7071 + if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" && 2.7072 + style.removeAttribute ) { 2.7073 + 2.7074 + // Setting style.filter to null, "" & " " still leave "filter:" in the cssText 2.7075 + // if "filter:" is present at all, clearType is disabled, we want to avoid this 2.7076 + // style.removeAttribute is IE Only, but so apparently is this code path... 2.7077 + style.removeAttribute( "filter" ); 2.7078 + 2.7079 + // if there there is no filter style applied in a css rule, we are done 2.7080 + if ( currentStyle && !currentStyle.filter ) { 2.7081 + return; 2.7082 + } 2.7083 + } 2.7084 + 2.7085 + // otherwise, set new filter values 2.7086 + style.filter = ralpha.test( filter ) ? 2.7087 + filter.replace( ralpha, opacity ) : 2.7088 + filter + " " + opacity; 2.7089 + } 2.7090 + }; 2.7091 +} 2.7092 + 2.7093 +// These hooks cannot be added until DOM ready because the support test 2.7094 +// for it is not run until after DOM ready 2.7095 +jQuery(function() { 2.7096 + if ( !jQuery.support.reliableMarginRight ) { 2.7097 + jQuery.cssHooks.marginRight = { 2.7098 + get: function( elem, computed ) { 2.7099 + // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 2.7100 + // Work around by temporarily setting element display to inline-block 2.7101 + return jQuery.swap( elem, { "display": "inline-block" }, function() { 2.7102 + if ( computed ) { 2.7103 + return curCSS( elem, "marginRight" ); 2.7104 + } 2.7105 + }); 2.7106 + } 2.7107 + }; 2.7108 + } 2.7109 + 2.7110 + // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 2.7111 + // getComputedStyle returns percent when specified for top/left/bottom/right 2.7112 + // rather than make the css module depend on the offset module, we just check for it here 2.7113 + if ( !jQuery.support.pixelPosition && jQuery.fn.position ) { 2.7114 + jQuery.each( [ "top", "left" ], function( i, prop ) { 2.7115 + jQuery.cssHooks[ prop ] = { 2.7116 + get: function( elem, computed ) { 2.7117 + if ( computed ) { 2.7118 + var ret = curCSS( elem, prop ); 2.7119 + // if curCSS returns percentage, fallback to offset 2.7120 + return rnumnonpx.test( ret ) ? jQuery( elem ).position()[ prop ] + "px" : ret; 2.7121 + } 2.7122 + } 2.7123 + }; 2.7124 + }); 2.7125 + } 2.7126 + 2.7127 +}); 2.7128 + 2.7129 +if ( jQuery.expr && jQuery.expr.filters ) { 2.7130 + jQuery.expr.filters.hidden = function( elem ) { 2.7131 + return ( elem.offsetWidth === 0 && elem.offsetHeight === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || curCSS( elem, "display" )) === "none"); 2.7132 + }; 2.7133 + 2.7134 + jQuery.expr.filters.visible = function( elem ) { 2.7135 + return !jQuery.expr.filters.hidden( elem ); 2.7136 + }; 2.7137 +} 2.7138 + 2.7139 +// These hooks are used by animate to expand properties 2.7140 +jQuery.each({ 2.7141 + margin: "", 2.7142 + padding: "", 2.7143 + border: "Width" 2.7144 +}, function( prefix, suffix ) { 2.7145 + jQuery.cssHooks[ prefix + suffix ] = { 2.7146 + expand: function( value ) { 2.7147 + var i, 2.7148 + 2.7149 + // assumes a single number if not a string 2.7150 + parts = typeof value === "string" ? value.split(" ") : [ value ], 2.7151 + expanded = {}; 2.7152 + 2.7153 + for ( i = 0; i < 4; i++ ) { 2.7154 + expanded[ prefix + cssExpand[ i ] + suffix ] = 2.7155 + parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; 2.7156 + } 2.7157 + 2.7158 + return expanded; 2.7159 + } 2.7160 + }; 2.7161 + 2.7162 + if ( !rmargin.test( prefix ) ) { 2.7163 + jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; 2.7164 + } 2.7165 +}); 2.7166 +var r20 = /%20/g, 2.7167 + rbracket = /\[\]$/, 2.7168 + rCRLF = /\r?\n/g, 2.7169 + rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i, 2.7170 + rselectTextarea = /^(?:select|textarea)/i; 2.7171 + 2.7172 +jQuery.fn.extend({ 2.7173 + serialize: function() { 2.7174 + return jQuery.param( this.serializeArray() ); 2.7175 + }, 2.7176 + serializeArray: function() { 2.7177 + return this.map(function(){ 2.7178 + return this.elements ? jQuery.makeArray( this.elements ) : this; 2.7179 + }) 2.7180 + .filter(function(){ 2.7181 + return this.name && !this.disabled && 2.7182 + ( this.checked || rselectTextarea.test( this.nodeName ) || 2.7183 + rinput.test( this.type ) ); 2.7184 + }) 2.7185 + .map(function( i, elem ){ 2.7186 + var val = jQuery( this ).val(); 2.7187 + 2.7188 + return val == null ? 2.7189 + null : 2.7190 + jQuery.isArray( val ) ? 2.7191 + jQuery.map( val, function( val, i ){ 2.7192 + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 2.7193 + }) : 2.7194 + { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 2.7195 + }).get(); 2.7196 + } 2.7197 +}); 2.7198 + 2.7199 +//Serialize an array of form elements or a set of 2.7200 +//key/values into a query string 2.7201 +jQuery.param = function( a, traditional ) { 2.7202 + var prefix, 2.7203 + s = [], 2.7204 + add = function( key, value ) { 2.7205 + // If value is a function, invoke it and return its value 2.7206 + value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value ); 2.7207 + s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value ); 2.7208 + }; 2.7209 + 2.7210 + // Set traditional to true for jQuery <= 1.3.2 behavior. 2.7211 + if ( traditional === undefined ) { 2.7212 + traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional; 2.7213 + } 2.7214 + 2.7215 + // If an array was passed in, assume that it is an array of form elements. 2.7216 + if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { 2.7217 + // Serialize the form elements 2.7218 + jQuery.each( a, function() { 2.7219 + add( this.name, this.value ); 2.7220 + }); 2.7221 + 2.7222 + } else { 2.7223 + // If traditional, encode the "old" way (the way 1.3.2 or older 2.7224 + // did it), otherwise encode params recursively. 2.7225 + for ( prefix in a ) { 2.7226 + buildParams( prefix, a[ prefix ], traditional, add ); 2.7227 + } 2.7228 + } 2.7229 + 2.7230 + // Return the resulting serialization 2.7231 + return s.join( "&" ).replace( r20, "+" ); 2.7232 +}; 2.7233 + 2.7234 +function buildParams( prefix, obj, traditional, add ) { 2.7235 + var name; 2.7236 + 2.7237 + if ( jQuery.isArray( obj ) ) { 2.7238 + // Serialize array item. 2.7239 + jQuery.each( obj, function( i, v ) { 2.7240 + if ( traditional || rbracket.test( prefix ) ) { 2.7241 + // Treat each array item as a scalar. 2.7242 + add( prefix, v ); 2.7243 + 2.7244 + } else { 2.7245 + // If array item is non-scalar (array or object), encode its 2.7246 + // numeric index to resolve deserialization ambiguity issues. 2.7247 + // Note that rack (as of 1.0.0) can't currently deserialize 2.7248 + // nested arrays properly, and attempting to do so may cause 2.7249 + // a server error. Possible fixes are to modify rack's 2.7250 + // deserialization algorithm or to provide an option or flag 2.7251 + // to force array serialization to be shallow. 2.7252 + buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add ); 2.7253 + } 2.7254 + }); 2.7255 + 2.7256 + } else if ( !traditional && jQuery.type( obj ) === "object" ) { 2.7257 + // Serialize object item. 2.7258 + for ( name in obj ) { 2.7259 + buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 2.7260 + } 2.7261 + 2.7262 + } else { 2.7263 + // Serialize scalar item. 2.7264 + add( prefix, obj ); 2.7265 + } 2.7266 +} 2.7267 +var 2.7268 + // Document location 2.7269 + ajaxLocParts, 2.7270 + ajaxLocation, 2.7271 + 2.7272 + rhash = /#.*$/, 2.7273 + rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL 2.7274 + // #7653, #8125, #8152: local protocol detection 2.7275 + rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/, 2.7276 + rnoContent = /^(?:GET|HEAD)$/, 2.7277 + rprotocol = /^\/\//, 2.7278 + rquery = /\?/, 2.7279 + rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, 2.7280 + rts = /([?&])_=[^&]*/, 2.7281 + rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/, 2.7282 + 2.7283 + // Keep a copy of the old load method 2.7284 + _load = jQuery.fn.load, 2.7285 + 2.7286 + /* Prefilters 2.7287 + * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 2.7288 + * 2) These are called: 2.7289 + * - BEFORE asking for a transport 2.7290 + * - AFTER param serialization (s.data is a string if s.processData is true) 2.7291 + * 3) key is the dataType 2.7292 + * 4) the catchall symbol "*" can be used 2.7293 + * 5) execution will start with transport dataType and THEN continue down to "*" if needed 2.7294 + */ 2.7295 + prefilters = {}, 2.7296 + 2.7297 + /* Transports bindings 2.7298 + * 1) key is the dataType 2.7299 + * 2) the catchall symbol "*" can be used 2.7300 + * 3) selection will start with transport dataType and THEN go to "*" if needed 2.7301 + */ 2.7302 + transports = {}, 2.7303 + 2.7304 + // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression 2.7305 + allTypes = ["*/"] + ["*"]; 2.7306 + 2.7307 +// #8138, IE may throw an exception when accessing 2.7308 +// a field from window.location if document.domain has been set 2.7309 +try { 2.7310 + ajaxLocation = location.href; 2.7311 +} catch( e ) { 2.7312 + // Use the href attribute of an A element 2.7313 + // since IE will modify it given document.location 2.7314 + ajaxLocation = document.createElement( "a" ); 2.7315 + ajaxLocation.href = ""; 2.7316 + ajaxLocation = ajaxLocation.href; 2.7317 +} 2.7318 + 2.7319 +// Segment location into parts 2.7320 +ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || []; 2.7321 + 2.7322 +// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 2.7323 +function addToPrefiltersOrTransports( structure ) { 2.7324 + 2.7325 + // dataTypeExpression is optional and defaults to "*" 2.7326 + return function( dataTypeExpression, func ) { 2.7327 + 2.7328 + if ( typeof dataTypeExpression !== "string" ) { 2.7329 + func = dataTypeExpression; 2.7330 + dataTypeExpression = "*"; 2.7331 + } 2.7332 + 2.7333 + var dataType, list, placeBefore, 2.7334 + dataTypes = dataTypeExpression.toLowerCase().split( core_rspace ), 2.7335 + i = 0, 2.7336 + length = dataTypes.length; 2.7337 + 2.7338 + if ( jQuery.isFunction( func ) ) { 2.7339 + // For each dataType in the dataTypeExpression 2.7340 + for ( ; i < length; i++ ) { 2.7341 + dataType = dataTypes[ i ]; 2.7342 + // We control if we're asked to add before 2.7343 + // any existing element 2.7344 + placeBefore = /^\+/.test( dataType ); 2.7345 + if ( placeBefore ) { 2.7346 + dataType = dataType.substr( 1 ) || "*"; 2.7347 + } 2.7348 + list = structure[ dataType ] = structure[ dataType ] || []; 2.7349 + // then we add to the structure accordingly 2.7350 + list[ placeBefore ? "unshift" : "push" ]( func ); 2.7351 + } 2.7352 + } 2.7353 + }; 2.7354 +} 2.7355 + 2.7356 +// Base inspection function for prefilters and transports 2.7357 +function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR, 2.7358 + dataType /* internal */, inspected /* internal */ ) { 2.7359 + 2.7360 + dataType = dataType || options.dataTypes[ 0 ]; 2.7361 + inspected = inspected || {}; 2.7362 + 2.7363 + inspected[ dataType ] = true; 2.7364 + 2.7365 + var selection, 2.7366 + list = structure[ dataType ], 2.7367 + i = 0, 2.7368 + length = list ? list.length : 0, 2.7369 + executeOnly = ( structure === prefilters ); 2.7370 + 2.7371 + for ( ; i < length && ( executeOnly || !selection ); i++ ) { 2.7372 + selection = list[ i ]( options, originalOptions, jqXHR ); 2.7373 + // If we got redirected to another dataType 2.7374 + // we try there if executing only and not done already 2.7375 + if ( typeof selection === "string" ) { 2.7376 + if ( !executeOnly || inspected[ selection ] ) { 2.7377 + selection = undefined; 2.7378 + } else { 2.7379 + options.dataTypes.unshift( selection ); 2.7380 + selection = inspectPrefiltersOrTransports( 2.7381 + structure, options, originalOptions, jqXHR, selection, inspected ); 2.7382 + } 2.7383 + } 2.7384 + } 2.7385 + // If we're only executing or nothing was selected 2.7386 + // we try the catchall dataType if not done already 2.7387 + if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) { 2.7388 + selection = inspectPrefiltersOrTransports( 2.7389 + structure, options, originalOptions, jqXHR, "*", inspected ); 2.7390 + } 2.7391 + // unnecessary when only executing (prefilters) 2.7392 + // but it'll be ignored by the caller in that case 2.7393 + return selection; 2.7394 +} 2.7395 + 2.7396 +// A special extend for ajax options 2.7397 +// that takes "flat" options (not to be deep extended) 2.7398 +// Fixes #9887 2.7399 +function ajaxExtend( target, src ) { 2.7400 + var key, deep, 2.7401 + flatOptions = jQuery.ajaxSettings.flatOptions || {}; 2.7402 + for ( key in src ) { 2.7403 + if ( src[ key ] !== undefined ) { 2.7404 + ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 2.7405 + } 2.7406 + } 2.7407 + if ( deep ) { 2.7408 + jQuery.extend( true, target, deep ); 2.7409 + } 2.7410 +} 2.7411 + 2.7412 +jQuery.fn.load = function( url, params, callback ) { 2.7413 + if ( typeof url !== "string" && _load ) { 2.7414 + return _load.apply( this, arguments ); 2.7415 + } 2.7416 + 2.7417 + // Don't do a request if no elements are being requested 2.7418 + if ( !this.length ) { 2.7419 + return this; 2.7420 + } 2.7421 + 2.7422 + var selector, type, response, 2.7423 + self = this, 2.7424 + off = url.indexOf(" "); 2.7425 + 2.7426 + if ( off >= 0 ) { 2.7427 + selector = url.slice( off, url.length ); 2.7428 + url = url.slice( 0, off ); 2.7429 + } 2.7430 + 2.7431 + // If it's a function 2.7432 + if ( jQuery.isFunction( params ) ) { 2.7433 + 2.7434 + // We assume that it's the callback 2.7435 + callback = params; 2.7436 + params = undefined; 2.7437 + 2.7438 + // Otherwise, build a param string 2.7439 + } else if ( params && typeof params === "object" ) { 2.7440 + type = "POST"; 2.7441 + } 2.7442 + 2.7443 + // Request the remote document 2.7444 + jQuery.ajax({ 2.7445 + url: url, 2.7446 + 2.7447 + // if "type" variable is undefined, then "GET" method will be used 2.7448 + type: type, 2.7449 + dataType: "html", 2.7450 + data: params, 2.7451 + complete: function( jqXHR, status ) { 2.7452 + if ( callback ) { 2.7453 + self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] ); 2.7454 + } 2.7455 + } 2.7456 + }).done(function( responseText ) { 2.7457 + 2.7458 + // Save response for use in complete callback 2.7459 + response = arguments; 2.7460 + 2.7461 + // See if a selector was specified 2.7462 + self.html( selector ? 2.7463 + 2.7464 + // Create a dummy div to hold the results 2.7465 + jQuery("<div>") 2.7466 + 2.7467 + // inject the contents of the document in, removing the scripts 2.7468 + // to avoid any 'Permission Denied' errors in IE 2.7469 + .append( responseText.replace( rscript, "" ) ) 2.7470 + 2.7471 + // Locate the specified elements 2.7472 + .find( selector ) : 2.7473 + 2.7474 + // If not, just inject the full result 2.7475 + responseText ); 2.7476 + 2.7477 + }); 2.7478 + 2.7479 + return this; 2.7480 +}; 2.7481 + 2.7482 +// Attach a bunch of functions for handling common AJAX events 2.7483 +jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){ 2.7484 + jQuery.fn[ o ] = function( f ){ 2.7485 + return this.on( o, f ); 2.7486 + }; 2.7487 +}); 2.7488 + 2.7489 +jQuery.each( [ "get", "post" ], function( i, method ) { 2.7490 + jQuery[ method ] = function( url, data, callback, type ) { 2.7491 + // shift arguments if data argument was omitted 2.7492 + if ( jQuery.isFunction( data ) ) { 2.7493 + type = type || callback; 2.7494 + callback = data; 2.7495 + data = undefined; 2.7496 + } 2.7497 + 2.7498 + return jQuery.ajax({ 2.7499 + type: method, 2.7500 + url: url, 2.7501 + data: data, 2.7502 + success: callback, 2.7503 + dataType: type 2.7504 + }); 2.7505 + }; 2.7506 +}); 2.7507 + 2.7508 +jQuery.extend({ 2.7509 + 2.7510 + getScript: function( url, callback ) { 2.7511 + return jQuery.get( url, undefined, callback, "script" ); 2.7512 + }, 2.7513 + 2.7514 + getJSON: function( url, data, callback ) { 2.7515 + return jQuery.get( url, data, callback, "json" ); 2.7516 + }, 2.7517 + 2.7518 + // Creates a full fledged settings object into target 2.7519 + // with both ajaxSettings and settings fields. 2.7520 + // If target is omitted, writes into ajaxSettings. 2.7521 + ajaxSetup: function( target, settings ) { 2.7522 + if ( settings ) { 2.7523 + // Building a settings object 2.7524 + ajaxExtend( target, jQuery.ajaxSettings ); 2.7525 + } else { 2.7526 + // Extending ajaxSettings 2.7527 + settings = target; 2.7528 + target = jQuery.ajaxSettings; 2.7529 + } 2.7530 + ajaxExtend( target, settings ); 2.7531 + return target; 2.7532 + }, 2.7533 + 2.7534 + ajaxSettings: { 2.7535 + url: ajaxLocation, 2.7536 + isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ), 2.7537 + global: true, 2.7538 + type: "GET", 2.7539 + contentType: "application/x-www-form-urlencoded; charset=UTF-8", 2.7540 + processData: true, 2.7541 + async: true, 2.7542 + /* 2.7543 + timeout: 0, 2.7544 + data: null, 2.7545 + dataType: null, 2.7546 + username: null, 2.7547 + password: null, 2.7548 + cache: null, 2.7549 + throws: false, 2.7550 + traditional: false, 2.7551 + headers: {}, 2.7552 + */ 2.7553 + 2.7554 + accepts: { 2.7555 + xml: "application/xml, text/xml", 2.7556 + html: "text/html", 2.7557 + text: "text/plain", 2.7558 + json: "application/json, text/javascript", 2.7559 + "*": allTypes 2.7560 + }, 2.7561 + 2.7562 + contents: { 2.7563 + xml: /xml/, 2.7564 + html: /html/, 2.7565 + json: /json/ 2.7566 + }, 2.7567 + 2.7568 + responseFields: { 2.7569 + xml: "responseXML", 2.7570 + text: "responseText" 2.7571 + }, 2.7572 + 2.7573 + // List of data converters 2.7574 + // 1) key format is "source_type destination_type" (a single space in-between) 2.7575 + // 2) the catchall symbol "*" can be used for source_type 2.7576 + converters: { 2.7577 + 2.7578 + // Convert anything to text 2.7579 + "* text": window.String, 2.7580 + 2.7581 + // Text to html (true = no transformation) 2.7582 + "text html": true, 2.7583 + 2.7584 + // Evaluate text as a json expression 2.7585 + "text json": jQuery.parseJSON, 2.7586 + 2.7587 + // Parse text as xml 2.7588 + "text xml": jQuery.parseXML 2.7589 + }, 2.7590 + 2.7591 + // For options that shouldn't be deep extended: 2.7592 + // you can add your own custom options here if 2.7593 + // and when you create one that shouldn't be 2.7594 + // deep extended (see ajaxExtend) 2.7595 + flatOptions: { 2.7596 + context: true, 2.7597 + url: true 2.7598 + } 2.7599 + }, 2.7600 + 2.7601 + ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), 2.7602 + ajaxTransport: addToPrefiltersOrTransports( transports ), 2.7603 + 2.7604 + // Main method 2.7605 + ajax: function( url, options ) { 2.7606 + 2.7607 + // If url is an object, simulate pre-1.5 signature 2.7608 + if ( typeof url === "object" ) { 2.7609 + options = url; 2.7610 + url = undefined; 2.7611 + } 2.7612 + 2.7613 + // Force options to be an object 2.7614 + options = options || {}; 2.7615 + 2.7616 + var // ifModified key 2.7617 + ifModifiedKey, 2.7618 + // Response headers 2.7619 + responseHeadersString, 2.7620 + responseHeaders, 2.7621 + // transport 2.7622 + transport, 2.7623 + // timeout handle 2.7624 + timeoutTimer, 2.7625 + // Cross-domain detection vars 2.7626 + parts, 2.7627 + // To know if global events are to be dispatched 2.7628 + fireGlobals, 2.7629 + // Loop variable 2.7630 + i, 2.7631 + // Create the final options object 2.7632 + s = jQuery.ajaxSetup( {}, options ), 2.7633 + // Callbacks context 2.7634 + callbackContext = s.context || s, 2.7635 + // Context for global events 2.7636 + // It's the callbackContext if one was provided in the options 2.7637 + // and if it's a DOM node or a jQuery collection 2.7638 + globalEventContext = callbackContext !== s && 2.7639 + ( callbackContext.nodeType || callbackContext instanceof jQuery ) ? 2.7640 + jQuery( callbackContext ) : jQuery.event, 2.7641 + // Deferreds 2.7642 + deferred = jQuery.Deferred(), 2.7643 + completeDeferred = jQuery.Callbacks( "once memory" ), 2.7644 + // Status-dependent callbacks 2.7645 + statusCode = s.statusCode || {}, 2.7646 + // Headers (they are sent all at once) 2.7647 + requestHeaders = {}, 2.7648 + requestHeadersNames = {}, 2.7649 + // The jqXHR state 2.7650 + state = 0, 2.7651 + // Default abort message 2.7652 + strAbort = "canceled", 2.7653 + // Fake xhr 2.7654 + jqXHR = { 2.7655 + 2.7656 + readyState: 0, 2.7657 + 2.7658 + // Caches the header 2.7659 + setRequestHeader: function( name, value ) { 2.7660 + if ( !state ) { 2.7661 + var lname = name.toLowerCase(); 2.7662 + name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name; 2.7663 + requestHeaders[ name ] = value; 2.7664 + } 2.7665 + return this; 2.7666 + }, 2.7667 + 2.7668 + // Raw string 2.7669 + getAllResponseHeaders: function() { 2.7670 + return state === 2 ? responseHeadersString : null; 2.7671 + }, 2.7672 + 2.7673 + // Builds headers hashtable if needed 2.7674 + getResponseHeader: function( key ) { 2.7675 + var match; 2.7676 + if ( state === 2 ) { 2.7677 + if ( !responseHeaders ) { 2.7678 + responseHeaders = {}; 2.7679 + while( ( match = rheaders.exec( responseHeadersString ) ) ) { 2.7680 + responseHeaders[ match[1].toLowerCase() ] = match[ 2 ]; 2.7681 + } 2.7682 + } 2.7683 + match = responseHeaders[ key.toLowerCase() ]; 2.7684 + } 2.7685 + return match === undefined ? null : match; 2.7686 + }, 2.7687 + 2.7688 + // Overrides response content-type header 2.7689 + overrideMimeType: function( type ) { 2.7690 + if ( !state ) { 2.7691 + s.mimeType = type; 2.7692 + } 2.7693 + return this; 2.7694 + }, 2.7695 + 2.7696 + // Cancel the request 2.7697 + abort: function( statusText ) { 2.7698 + statusText = statusText || strAbort; 2.7699 + if ( transport ) { 2.7700 + transport.abort( statusText ); 2.7701 + } 2.7702 + done( 0, statusText ); 2.7703 + return this; 2.7704 + } 2.7705 + }; 2.7706 + 2.7707 + // Callback for when everything is done 2.7708 + // It is defined here because jslint complains if it is declared 2.7709 + // at the end of the function (which would be more logical and readable) 2.7710 + function done( status, nativeStatusText, responses, headers ) { 2.7711 + var isSuccess, success, error, response, modified, 2.7712 + statusText = nativeStatusText; 2.7713 + 2.7714 + // Called once 2.7715 + if ( state === 2 ) { 2.7716 + return; 2.7717 + } 2.7718 + 2.7719 + // State is "done" now 2.7720 + state = 2; 2.7721 + 2.7722 + // Clear timeout if it exists 2.7723 + if ( timeoutTimer ) { 2.7724 + clearTimeout( timeoutTimer ); 2.7725 + } 2.7726 + 2.7727 + // Dereference transport for early garbage collection 2.7728 + // (no matter how long the jqXHR object will be used) 2.7729 + transport = undefined; 2.7730 + 2.7731 + // Cache response headers 2.7732 + responseHeadersString = headers || ""; 2.7733 + 2.7734 + // Set readyState 2.7735 + jqXHR.readyState = status > 0 ? 4 : 0; 2.7736 + 2.7737 + // Get response data 2.7738 + if ( responses ) { 2.7739 + response = ajaxHandleResponses( s, jqXHR, responses ); 2.7740 + } 2.7741 + 2.7742 + // If successful, handle type chaining 2.7743 + if ( status >= 200 && status < 300 || status === 304 ) { 2.7744 + 2.7745 + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 2.7746 + if ( s.ifModified ) { 2.7747 + 2.7748 + modified = jqXHR.getResponseHeader("Last-Modified"); 2.7749 + if ( modified ) { 2.7750 + jQuery.lastModified[ ifModifiedKey ] = modified; 2.7751 + } 2.7752 + modified = jqXHR.getResponseHeader("Etag"); 2.7753 + if ( modified ) { 2.7754 + jQuery.etag[ ifModifiedKey ] = modified; 2.7755 + } 2.7756 + } 2.7757 + 2.7758 + // If not modified 2.7759 + if ( status === 304 ) { 2.7760 + 2.7761 + statusText = "notmodified"; 2.7762 + isSuccess = true; 2.7763 + 2.7764 + // If we have data 2.7765 + } else { 2.7766 + 2.7767 + isSuccess = ajaxConvert( s, response ); 2.7768 + statusText = isSuccess.state; 2.7769 + success = isSuccess.data; 2.7770 + error = isSuccess.error; 2.7771 + isSuccess = !error; 2.7772 + } 2.7773 + } else { 2.7774 + // We extract error from statusText 2.7775 + // then normalize statusText and status for non-aborts 2.7776 + error = statusText; 2.7777 + if ( !statusText || status ) { 2.7778 + statusText = "error"; 2.7779 + if ( status < 0 ) { 2.7780 + status = 0; 2.7781 + } 2.7782 + } 2.7783 + } 2.7784 + 2.7785 + // Set data for the fake xhr object 2.7786 + jqXHR.status = status; 2.7787 + jqXHR.statusText = ( nativeStatusText || statusText ) + ""; 2.7788 + 2.7789 + // Success/Error 2.7790 + if ( isSuccess ) { 2.7791 + deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); 2.7792 + } else { 2.7793 + deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); 2.7794 + } 2.7795 + 2.7796 + // Status-dependent callbacks 2.7797 + jqXHR.statusCode( statusCode ); 2.7798 + statusCode = undefined; 2.7799 + 2.7800 + if ( fireGlobals ) { 2.7801 + globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ), 2.7802 + [ jqXHR, s, isSuccess ? success : error ] ); 2.7803 + } 2.7804 + 2.7805 + // Complete 2.7806 + completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 2.7807 + 2.7808 + if ( fireGlobals ) { 2.7809 + globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); 2.7810 + // Handle the global AJAX counter 2.7811 + if ( !( --jQuery.active ) ) { 2.7812 + jQuery.event.trigger( "ajaxStop" ); 2.7813 + } 2.7814 + } 2.7815 + } 2.7816 + 2.7817 + // Attach deferreds 2.7818 + deferred.promise( jqXHR ); 2.7819 + jqXHR.success = jqXHR.done; 2.7820 + jqXHR.error = jqXHR.fail; 2.7821 + jqXHR.complete = completeDeferred.add; 2.7822 + 2.7823 + // Status-dependent callbacks 2.7824 + jqXHR.statusCode = function( map ) { 2.7825 + if ( map ) { 2.7826 + var tmp; 2.7827 + if ( state < 2 ) { 2.7828 + for ( tmp in map ) { 2.7829 + statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ]; 2.7830 + } 2.7831 + } else { 2.7832 + tmp = map[ jqXHR.status ]; 2.7833 + jqXHR.always( tmp ); 2.7834 + } 2.7835 + } 2.7836 + return this; 2.7837 + }; 2.7838 + 2.7839 + // Remove hash character (#7531: and string promotion) 2.7840 + // Add protocol if not provided (#5866: IE7 issue with protocol-less urls) 2.7841 + // We also use the url parameter if available 2.7842 + s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" ); 2.7843 + 2.7844 + // Extract dataTypes list 2.7845 + s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( core_rspace ); 2.7846 + 2.7847 + // A cross-domain request is in order when we have a protocol:host:port mismatch 2.7848 + if ( s.crossDomain == null ) { 2.7849 + parts = rurl.exec( s.url.toLowerCase() ) || false; 2.7850 + s.crossDomain = parts && ( parts.join(":") + ( parts[ 3 ] ? "" : parts[ 1 ] === "http:" ? 80 : 443 ) ) !== 2.7851 + ( ajaxLocParts.join(":") + ( ajaxLocParts[ 3 ] ? "" : ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ); 2.7852 + } 2.7853 + 2.7854 + // Convert data if not already a string 2.7855 + if ( s.data && s.processData && typeof s.data !== "string" ) { 2.7856 + s.data = jQuery.param( s.data, s.traditional ); 2.7857 + } 2.7858 + 2.7859 + // Apply prefilters 2.7860 + inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); 2.7861 + 2.7862 + // If request was aborted inside a prefilter, stop there 2.7863 + if ( state === 2 ) { 2.7864 + return jqXHR; 2.7865 + } 2.7866 + 2.7867 + // We can fire global events as of now if asked to 2.7868 + fireGlobals = s.global; 2.7869 + 2.7870 + // Uppercase the type 2.7871 + s.type = s.type.toUpperCase(); 2.7872 + 2.7873 + // Determine if request has content 2.7874 + s.hasContent = !rnoContent.test( s.type ); 2.7875 + 2.7876 + // Watch for a new set of requests 2.7877 + if ( fireGlobals && jQuery.active++ === 0 ) { 2.7878 + jQuery.event.trigger( "ajaxStart" ); 2.7879 + } 2.7880 + 2.7881 + // More options handling for requests with no content 2.7882 + if ( !s.hasContent ) { 2.7883 + 2.7884 + // If data is available, append data to url 2.7885 + if ( s.data ) { 2.7886 + s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data; 2.7887 + // #9682: remove data so that it's not used in an eventual retry 2.7888 + delete s.data; 2.7889 + } 2.7890 + 2.7891 + // Get ifModifiedKey before adding the anti-cache parameter 2.7892 + ifModifiedKey = s.url; 2.7893 + 2.7894 + // Add anti-cache in url if needed 2.7895 + if ( s.cache === false ) { 2.7896 + 2.7897 + var ts = jQuery.now(), 2.7898 + // try replacing _= if it is there 2.7899 + ret = s.url.replace( rts, "$1_=" + ts ); 2.7900 + 2.7901 + // if nothing was replaced, add timestamp to the end 2.7902 + s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" ); 2.7903 + } 2.7904 + } 2.7905 + 2.7906 + // Set the correct header, if data is being sent 2.7907 + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 2.7908 + jqXHR.setRequestHeader( "Content-Type", s.contentType ); 2.7909 + } 2.7910 + 2.7911 + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 2.7912 + if ( s.ifModified ) { 2.7913 + ifModifiedKey = ifModifiedKey || s.url; 2.7914 + if ( jQuery.lastModified[ ifModifiedKey ] ) { 2.7915 + jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] ); 2.7916 + } 2.7917 + if ( jQuery.etag[ ifModifiedKey ] ) { 2.7918 + jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] ); 2.7919 + } 2.7920 + } 2.7921 + 2.7922 + // Set the Accepts header for the server, depending on the dataType 2.7923 + jqXHR.setRequestHeader( 2.7924 + "Accept", 2.7925 + s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ? 2.7926 + s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : 2.7927 + s.accepts[ "*" ] 2.7928 + ); 2.7929 + 2.7930 + // Check for headers option 2.7931 + for ( i in s.headers ) { 2.7932 + jqXHR.setRequestHeader( i, s.headers[ i ] ); 2.7933 + } 2.7934 + 2.7935 + // Allow custom headers/mimetypes and early abort 2.7936 + if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) { 2.7937 + // Abort if not done already and return 2.7938 + return jqXHR.abort(); 2.7939 + 2.7940 + } 2.7941 + 2.7942 + // aborting is no longer a cancellation 2.7943 + strAbort = "abort"; 2.7944 + 2.7945 + // Install callbacks on deferreds 2.7946 + for ( i in { success: 1, error: 1, complete: 1 } ) { 2.7947 + jqXHR[ i ]( s[ i ] ); 2.7948 + } 2.7949 + 2.7950 + // Get transport 2.7951 + transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); 2.7952 + 2.7953 + // If no transport, we auto-abort 2.7954 + if ( !transport ) { 2.7955 + done( -1, "No Transport" ); 2.7956 + } else { 2.7957 + jqXHR.readyState = 1; 2.7958 + // Send global event 2.7959 + if ( fireGlobals ) { 2.7960 + globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); 2.7961 + } 2.7962 + // Timeout 2.7963 + if ( s.async && s.timeout > 0 ) { 2.7964 + timeoutTimer = setTimeout( function(){ 2.7965 + jqXHR.abort( "timeout" ); 2.7966 + }, s.timeout ); 2.7967 + } 2.7968 + 2.7969 + try { 2.7970 + state = 1; 2.7971 + transport.send( requestHeaders, done ); 2.7972 + } catch (e) { 2.7973 + // Propagate exception as error if not done 2.7974 + if ( state < 2 ) { 2.7975 + done( -1, e ); 2.7976 + // Simply rethrow otherwise 2.7977 + } else { 2.7978 + throw e; 2.7979 + } 2.7980 + } 2.7981 + } 2.7982 + 2.7983 + return jqXHR; 2.7984 + }, 2.7985 + 2.7986 + // Counter for holding the number of active queries 2.7987 + active: 0, 2.7988 + 2.7989 + // Last-Modified header cache for next request 2.7990 + lastModified: {}, 2.7991 + etag: {} 2.7992 + 2.7993 +}); 2.7994 + 2.7995 +/* Handles responses to an ajax request: 2.7996 + * - sets all responseXXX fields accordingly 2.7997 + * - finds the right dataType (mediates between content-type and expected dataType) 2.7998 + * - returns the corresponding response 2.7999 + */ 2.8000 +function ajaxHandleResponses( s, jqXHR, responses ) { 2.8001 + 2.8002 + var ct, type, finalDataType, firstDataType, 2.8003 + contents = s.contents, 2.8004 + dataTypes = s.dataTypes, 2.8005 + responseFields = s.responseFields; 2.8006 + 2.8007 + // Fill responseXXX fields 2.8008 + for ( type in responseFields ) { 2.8009 + if ( type in responses ) { 2.8010 + jqXHR[ responseFields[type] ] = responses[ type ]; 2.8011 + } 2.8012 + } 2.8013 + 2.8014 + // Remove auto dataType and get content-type in the process 2.8015 + while( dataTypes[ 0 ] === "*" ) { 2.8016 + dataTypes.shift(); 2.8017 + if ( ct === undefined ) { 2.8018 + ct = s.mimeType || jqXHR.getResponseHeader( "content-type" ); 2.8019 + } 2.8020 + } 2.8021 + 2.8022 + // Check if we're dealing with a known content-type 2.8023 + if ( ct ) { 2.8024 + for ( type in contents ) { 2.8025 + if ( contents[ type ] && contents[ type ].test( ct ) ) { 2.8026 + dataTypes.unshift( type ); 2.8027 + break; 2.8028 + } 2.8029 + } 2.8030 + } 2.8031 + 2.8032 + // Check to see if we have a response for the expected dataType 2.8033 + if ( dataTypes[ 0 ] in responses ) { 2.8034 + finalDataType = dataTypes[ 0 ]; 2.8035 + } else { 2.8036 + // Try convertible dataTypes 2.8037 + for ( type in responses ) { 2.8038 + if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) { 2.8039 + finalDataType = type; 2.8040 + break; 2.8041 + } 2.8042 + if ( !firstDataType ) { 2.8043 + firstDataType = type; 2.8044 + } 2.8045 + } 2.8046 + // Or just use first one 2.8047 + finalDataType = finalDataType || firstDataType; 2.8048 + } 2.8049 + 2.8050 + // If we found a dataType 2.8051 + // We add the dataType to the list if needed 2.8052 + // and return the corresponding response 2.8053 + if ( finalDataType ) { 2.8054 + if ( finalDataType !== dataTypes[ 0 ] ) { 2.8055 + dataTypes.unshift( finalDataType ); 2.8056 + } 2.8057 + return responses[ finalDataType ]; 2.8058 + } 2.8059 +} 2.8060 + 2.8061 +// Chain conversions given the request and the original response 2.8062 +function ajaxConvert( s, response ) { 2.8063 + 2.8064 + var conv, conv2, current, tmp, 2.8065 + // Work with a copy of dataTypes in case we need to modify it for conversion 2.8066 + dataTypes = s.dataTypes.slice(), 2.8067 + prev = dataTypes[ 0 ], 2.8068 + converters = {}, 2.8069 + i = 0; 2.8070 + 2.8071 + // Apply the dataFilter if provided 2.8072 + if ( s.dataFilter ) { 2.8073 + response = s.dataFilter( response, s.dataType ); 2.8074 + } 2.8075 + 2.8076 + // Create converters map with lowercased keys 2.8077 + if ( dataTypes[ 1 ] ) { 2.8078 + for ( conv in s.converters ) { 2.8079 + converters[ conv.toLowerCase() ] = s.converters[ conv ]; 2.8080 + } 2.8081 + } 2.8082 + 2.8083 + // Convert to each sequential dataType, tolerating list modification 2.8084 + for ( ; (current = dataTypes[++i]); ) { 2.8085 + 2.8086 + // There's only work to do if current dataType is non-auto 2.8087 + if ( current !== "*" ) { 2.8088 + 2.8089 + // Convert response if prev dataType is non-auto and differs from current 2.8090 + if ( prev !== "*" && prev !== current ) { 2.8091 + 2.8092 + // Seek a direct converter 2.8093 + conv = converters[ prev + " " + current ] || converters[ "* " + current ]; 2.8094 + 2.8095 + // If none found, seek a pair 2.8096 + if ( !conv ) { 2.8097 + for ( conv2 in converters ) { 2.8098 + 2.8099 + // If conv2 outputs current 2.8100 + tmp = conv2.split(" "); 2.8101 + if ( tmp[ 1 ] === current ) { 2.8102 + 2.8103 + // If prev can be converted to accepted input 2.8104 + conv = converters[ prev + " " + tmp[ 0 ] ] || 2.8105 + converters[ "* " + tmp[ 0 ] ]; 2.8106 + if ( conv ) { 2.8107 + // Condense equivalence converters 2.8108 + if ( conv === true ) { 2.8109 + conv = converters[ conv2 ]; 2.8110 + 2.8111 + // Otherwise, insert the intermediate dataType 2.8112 + } else if ( converters[ conv2 ] !== true ) { 2.8113 + current = tmp[ 0 ]; 2.8114 + dataTypes.splice( i--, 0, current ); 2.8115 + } 2.8116 + 2.8117 + break; 2.8118 + } 2.8119 + } 2.8120 + } 2.8121 + } 2.8122 + 2.8123 + // Apply converter (if not an equivalence) 2.8124 + if ( conv !== true ) { 2.8125 + 2.8126 + // Unless errors are allowed to bubble, catch and return them 2.8127 + if ( conv && s["throws"] ) { 2.8128 + response = conv( response ); 2.8129 + } else { 2.8130 + try { 2.8131 + response = conv( response ); 2.8132 + } catch ( e ) { 2.8133 + return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current }; 2.8134 + } 2.8135 + } 2.8136 + } 2.8137 + } 2.8138 + 2.8139 + // Update prev for next iteration 2.8140 + prev = current; 2.8141 + } 2.8142 + } 2.8143 + 2.8144 + return { state: "success", data: response }; 2.8145 +} 2.8146 +var oldCallbacks = [], 2.8147 + rquestion = /\?/, 2.8148 + rjsonp = /(=)\?(?=&|$)|\?\?/, 2.8149 + nonce = jQuery.now(); 2.8150 + 2.8151 +// Default jsonp settings 2.8152 +jQuery.ajaxSetup({ 2.8153 + jsonp: "callback", 2.8154 + jsonpCallback: function() { 2.8155 + var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) ); 2.8156 + this[ callback ] = true; 2.8157 + return callback; 2.8158 + } 2.8159 +}); 2.8160 + 2.8161 +// Detect, normalize options and install callbacks for jsonp requests 2.8162 +jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 2.8163 + 2.8164 + var callbackName, overwritten, responseContainer, 2.8165 + data = s.data, 2.8166 + url = s.url, 2.8167 + hasCallback = s.jsonp !== false, 2.8168 + replaceInUrl = hasCallback && rjsonp.test( url ), 2.8169 + replaceInData = hasCallback && !replaceInUrl && typeof data === "string" && 2.8170 + !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && 2.8171 + rjsonp.test( data ); 2.8172 + 2.8173 + // Handle iff the expected data type is "jsonp" or we have a parameter to set 2.8174 + if ( s.dataTypes[ 0 ] === "jsonp" || replaceInUrl || replaceInData ) { 2.8175 + 2.8176 + // Get callback name, remembering preexisting value associated with it 2.8177 + callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ? 2.8178 + s.jsonpCallback() : 2.8179 + s.jsonpCallback; 2.8180 + overwritten = window[ callbackName ]; 2.8181 + 2.8182 + // Insert callback into url or form data 2.8183 + if ( replaceInUrl ) { 2.8184 + s.url = url.replace( rjsonp, "$1" + callbackName ); 2.8185 + } else if ( replaceInData ) { 2.8186 + s.data = data.replace( rjsonp, "$1" + callbackName ); 2.8187 + } else if ( hasCallback ) { 2.8188 + s.url += ( rquestion.test( url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; 2.8189 + } 2.8190 + 2.8191 + // Use data converter to retrieve json after script execution 2.8192 + s.converters["script json"] = function() { 2.8193 + if ( !responseContainer ) { 2.8194 + jQuery.error( callbackName + " was not called" ); 2.8195 + } 2.8196 + return responseContainer[ 0 ]; 2.8197 + }; 2.8198 + 2.8199 + // force json dataType 2.8200 + s.dataTypes[ 0 ] = "json"; 2.8201 + 2.8202 + // Install callback 2.8203 + window[ callbackName ] = function() { 2.8204 + responseContainer = arguments; 2.8205 + }; 2.8206 + 2.8207 + // Clean-up function (fires after converters) 2.8208 + jqXHR.always(function() { 2.8209 + // Restore preexisting value 2.8210 + window[ callbackName ] = overwritten; 2.8211 + 2.8212 + // Save back as free 2.8213 + if ( s[ callbackName ] ) { 2.8214 + // make sure that re-using the options doesn't screw things around 2.8215 + s.jsonpCallback = originalSettings.jsonpCallback; 2.8216 + 2.8217 + // save the callback name for future use 2.8218 + oldCallbacks.push( callbackName ); 2.8219 + } 2.8220 + 2.8221 + // Call if it was a function and we have a response 2.8222 + if ( responseContainer && jQuery.isFunction( overwritten ) ) { 2.8223 + overwritten( responseContainer[ 0 ] ); 2.8224 + } 2.8225 + 2.8226 + responseContainer = overwritten = undefined; 2.8227 + }); 2.8228 + 2.8229 + // Delegate to script 2.8230 + return "script"; 2.8231 + } 2.8232 +}); 2.8233 +// Install script dataType 2.8234 +jQuery.ajaxSetup({ 2.8235 + accepts: { 2.8236 + script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript" 2.8237 + }, 2.8238 + contents: { 2.8239 + script: /javascript|ecmascript/ 2.8240 + }, 2.8241 + converters: { 2.8242 + "text script": function( text ) { 2.8243 + jQuery.globalEval( text ); 2.8244 + return text; 2.8245 + } 2.8246 + } 2.8247 +}); 2.8248 + 2.8249 +// Handle cache's special case and global 2.8250 +jQuery.ajaxPrefilter( "script", function( s ) { 2.8251 + if ( s.cache === undefined ) { 2.8252 + s.cache = false; 2.8253 + } 2.8254 + if ( s.crossDomain ) { 2.8255 + s.type = "GET"; 2.8256 + s.global = false; 2.8257 + } 2.8258 +}); 2.8259 + 2.8260 +// Bind script tag hack transport 2.8261 +jQuery.ajaxTransport( "script", function(s) { 2.8262 + 2.8263 + // This transport only deals with cross domain requests 2.8264 + if ( s.crossDomain ) { 2.8265 + 2.8266 + var script, 2.8267 + head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement; 2.8268 + 2.8269 + return { 2.8270 + 2.8271 + send: function( _, callback ) { 2.8272 + 2.8273 + script = document.createElement( "script" ); 2.8274 + 2.8275 + script.async = "async"; 2.8276 + 2.8277 + if ( s.scriptCharset ) { 2.8278 + script.charset = s.scriptCharset; 2.8279 + } 2.8280 + 2.8281 + script.src = s.url; 2.8282 + 2.8283 + // Attach handlers for all browsers 2.8284 + script.onload = script.onreadystatechange = function( _, isAbort ) { 2.8285 + 2.8286 + if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) { 2.8287 + 2.8288 + // Handle memory leak in IE 2.8289 + script.onload = script.onreadystatechange = null; 2.8290 + 2.8291 + // Remove the script 2.8292 + if ( head && script.parentNode ) { 2.8293 + head.removeChild( script ); 2.8294 + } 2.8295 + 2.8296 + // Dereference the script 2.8297 + script = undefined; 2.8298 + 2.8299 + // Callback if not abort 2.8300 + if ( !isAbort ) { 2.8301 + callback( 200, "success" ); 2.8302 + } 2.8303 + } 2.8304 + }; 2.8305 + // Use insertBefore instead of appendChild to circumvent an IE6 bug. 2.8306 + // This arises when a base node is used (#2709 and #4378). 2.8307 + head.insertBefore( script, head.firstChild ); 2.8308 + }, 2.8309 + 2.8310 + abort: function() { 2.8311 + if ( script ) { 2.8312 + script.onload( 0, 1 ); 2.8313 + } 2.8314 + } 2.8315 + }; 2.8316 + } 2.8317 +}); 2.8318 +var xhrCallbacks, 2.8319 + // #5280: Internet Explorer will keep connections alive if we don't abort on unload 2.8320 + xhrOnUnloadAbort = window.ActiveXObject ? function() { 2.8321 + // Abort all pending requests 2.8322 + for ( var key in xhrCallbacks ) { 2.8323 + xhrCallbacks[ key ]( 0, 1 ); 2.8324 + } 2.8325 + } : false, 2.8326 + xhrId = 0; 2.8327 + 2.8328 +// Functions to create xhrs 2.8329 +function createStandardXHR() { 2.8330 + try { 2.8331 + return new window.XMLHttpRequest(); 2.8332 + } catch( e ) {} 2.8333 +} 2.8334 + 2.8335 +function createActiveXHR() { 2.8336 + try { 2.8337 + return new window.ActiveXObject( "Microsoft.XMLHTTP" ); 2.8338 + } catch( e ) {} 2.8339 +} 2.8340 + 2.8341 +// Create the request object 2.8342 +// (This is still attached to ajaxSettings for backward compatibility) 2.8343 +jQuery.ajaxSettings.xhr = window.ActiveXObject ? 2.8344 + /* Microsoft failed to properly 2.8345 + * implement the XMLHttpRequest in IE7 (can't request local files), 2.8346 + * so we use the ActiveXObject when it is available 2.8347 + * Additionally XMLHttpRequest can be disabled in IE7/IE8 so 2.8348 + * we need a fallback. 2.8349 + */ 2.8350 + function() { 2.8351 + return !this.isLocal && createStandardXHR() || createActiveXHR(); 2.8352 + } : 2.8353 + // For all other browsers, use the standard XMLHttpRequest object 2.8354 + createStandardXHR; 2.8355 + 2.8356 +// Determine support properties 2.8357 +(function( xhr ) { 2.8358 + jQuery.extend( jQuery.support, { 2.8359 + ajax: !!xhr, 2.8360 + cors: !!xhr && ( "withCredentials" in xhr ) 2.8361 + }); 2.8362 +})( jQuery.ajaxSettings.xhr() ); 2.8363 + 2.8364 +// Create transport if the browser can provide an xhr 2.8365 +if ( jQuery.support.ajax ) { 2.8366 + 2.8367 + jQuery.ajaxTransport(function( s ) { 2.8368 + // Cross domain only allowed if supported through XMLHttpRequest 2.8369 + if ( !s.crossDomain || jQuery.support.cors ) { 2.8370 + 2.8371 + var callback; 2.8372 + 2.8373 + return { 2.8374 + send: function( headers, complete ) { 2.8375 + 2.8376 + // Get a new xhr 2.8377 + var handle, i, 2.8378 + xhr = s.xhr(); 2.8379 + 2.8380 + // Open the socket 2.8381 + // Passing null username, generates a login popup on Opera (#2865) 2.8382 + if ( s.username ) { 2.8383 + xhr.open( s.type, s.url, s.async, s.username, s.password ); 2.8384 + } else { 2.8385 + xhr.open( s.type, s.url, s.async ); 2.8386 + } 2.8387 + 2.8388 + // Apply custom fields if provided 2.8389 + if ( s.xhrFields ) { 2.8390 + for ( i in s.xhrFields ) { 2.8391 + xhr[ i ] = s.xhrFields[ i ]; 2.8392 + } 2.8393 + } 2.8394 + 2.8395 + // Override mime type if needed 2.8396 + if ( s.mimeType && xhr.overrideMimeType ) { 2.8397 + xhr.overrideMimeType( s.mimeType ); 2.8398 + } 2.8399 + 2.8400 + // X-Requested-With header 2.8401 + // For cross-domain requests, seeing as conditions for a preflight are 2.8402 + // akin to a jigsaw puzzle, we simply never set it to be sure. 2.8403 + // (it can always be set on a per-request basis or even using ajaxSetup) 2.8404 + // For same-domain requests, won't change header if already provided. 2.8405 + if ( !s.crossDomain && !headers["X-Requested-With"] ) { 2.8406 + headers[ "X-Requested-With" ] = "XMLHttpRequest"; 2.8407 + } 2.8408 + 2.8409 + // Need an extra try/catch for cross domain requests in Firefox 3 2.8410 + try { 2.8411 + for ( i in headers ) { 2.8412 + xhr.setRequestHeader( i, headers[ i ] ); 2.8413 + } 2.8414 + } catch( _ ) {} 2.8415 + 2.8416 + // Do send the request 2.8417 + // This may raise an exception which is actually 2.8418 + // handled in jQuery.ajax (so no try/catch here) 2.8419 + xhr.send( ( s.hasContent && s.data ) || null ); 2.8420 + 2.8421 + // Listener 2.8422 + callback = function( _, isAbort ) { 2.8423 + 2.8424 + var status, 2.8425 + statusText, 2.8426 + responseHeaders, 2.8427 + responses, 2.8428 + xml; 2.8429 + 2.8430 + // Firefox throws exceptions when accessing properties 2.8431 + // of an xhr when a network error occurred 2.8432 + // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE) 2.8433 + try { 2.8434 + 2.8435 + // Was never called and is aborted or complete 2.8436 + if ( callback && ( isAbort || xhr.readyState === 4 ) ) { 2.8437 + 2.8438 + // Only called once 2.8439 + callback = undefined; 2.8440 + 2.8441 + // Do not keep as active anymore 2.8442 + if ( handle ) { 2.8443 + xhr.onreadystatechange = jQuery.noop; 2.8444 + if ( xhrOnUnloadAbort ) { 2.8445 + delete xhrCallbacks[ handle ]; 2.8446 + } 2.8447 + } 2.8448 + 2.8449 + // If it's an abort 2.8450 + if ( isAbort ) { 2.8451 + // Abort it manually if needed 2.8452 + if ( xhr.readyState !== 4 ) { 2.8453 + xhr.abort(); 2.8454 + } 2.8455 + } else { 2.8456 + status = xhr.status; 2.8457 + responseHeaders = xhr.getAllResponseHeaders(); 2.8458 + responses = {}; 2.8459 + xml = xhr.responseXML; 2.8460 + 2.8461 + // Construct response list 2.8462 + if ( xml && xml.documentElement /* #4958 */ ) { 2.8463 + responses.xml = xml; 2.8464 + } 2.8465 + 2.8466 + // When requesting binary data, IE6-9 will throw an exception 2.8467 + // on any attempt to access responseText (#11426) 2.8468 + try { 2.8469 + responses.text = xhr.responseText; 2.8470 + } catch( _ ) { 2.8471 + } 2.8472 + 2.8473 + // Firefox throws an exception when accessing 2.8474 + // statusText for faulty cross-domain requests 2.8475 + try { 2.8476 + statusText = xhr.statusText; 2.8477 + } catch( e ) { 2.8478 + // We normalize with Webkit giving an empty statusText 2.8479 + statusText = ""; 2.8480 + } 2.8481 + 2.8482 + // Filter status for non standard behaviors 2.8483 + 2.8484 + // If the request is local and we have data: assume a success 2.8485 + // (success with no data won't get notified, that's the best we 2.8486 + // can do given current implementations) 2.8487 + if ( !status && s.isLocal && !s.crossDomain ) { 2.8488 + status = responses.text ? 200 : 404; 2.8489 + // IE - #1450: sometimes returns 1223 when it should be 204 2.8490 + } else if ( status === 1223 ) { 2.8491 + status = 204; 2.8492 + } 2.8493 + } 2.8494 + } 2.8495 + } catch( firefoxAccessException ) { 2.8496 + if ( !isAbort ) { 2.8497 + complete( -1, firefoxAccessException ); 2.8498 + } 2.8499 + } 2.8500 + 2.8501 + // Call complete if needed 2.8502 + if ( responses ) { 2.8503 + complete( status, statusText, responses, responseHeaders ); 2.8504 + } 2.8505 + }; 2.8506 + 2.8507 + if ( !s.async ) { 2.8508 + // if we're in sync mode we fire the callback 2.8509 + callback(); 2.8510 + } else if ( xhr.readyState === 4 ) { 2.8511 + // (IE6 & IE7) if it's in cache and has been 2.8512 + // retrieved directly we need to fire the callback 2.8513 + setTimeout( callback, 0 ); 2.8514 + } else { 2.8515 + handle = ++xhrId; 2.8516 + if ( xhrOnUnloadAbort ) { 2.8517 + // Create the active xhrs callbacks list if needed 2.8518 + // and attach the unload handler 2.8519 + if ( !xhrCallbacks ) { 2.8520 + xhrCallbacks = {}; 2.8521 + jQuery( window ).unload( xhrOnUnloadAbort ); 2.8522 + } 2.8523 + // Add to list of active xhrs callbacks 2.8524 + xhrCallbacks[ handle ] = callback; 2.8525 + } 2.8526 + xhr.onreadystatechange = callback; 2.8527 + } 2.8528 + }, 2.8529 + 2.8530 + abort: function() { 2.8531 + if ( callback ) { 2.8532 + callback(0,1); 2.8533 + } 2.8534 + } 2.8535 + }; 2.8536 + } 2.8537 + }); 2.8538 +} 2.8539 +var fxNow, timerId, 2.8540 + rfxtypes = /^(?:toggle|show|hide)$/, 2.8541 + rfxnum = new RegExp( "^(?:([-+])=|)(" + core_pnum + ")([a-z%]*)$", "i" ), 2.8542 + rrun = /queueHooks$/, 2.8543 + animationPrefilters = [ defaultPrefilter ], 2.8544 + tweeners = { 2.8545 + "*": [function( prop, value ) { 2.8546 + var end, unit, 2.8547 + tween = this.createTween( prop, value ), 2.8548 + parts = rfxnum.exec( value ), 2.8549 + target = tween.cur(), 2.8550 + start = +target || 0, 2.8551 + scale = 1, 2.8552 + maxIterations = 20; 2.8553 + 2.8554 + if ( parts ) { 2.8555 + end = +parts[2]; 2.8556 + unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 2.8557 + 2.8558 + // We need to compute starting value 2.8559 + if ( unit !== "px" && start ) { 2.8560 + // Iteratively approximate from a nonzero starting point 2.8561 + // Prefer the current property, because this process will be trivial if it uses the same units 2.8562 + // Fallback to end or a simple constant 2.8563 + start = jQuery.css( tween.elem, prop, true ) || end || 1; 2.8564 + 2.8565 + do { 2.8566 + // If previous iteration zeroed out, double until we get *something* 2.8567 + // Use a string for doubling factor so we don't accidentally see scale as unchanged below 2.8568 + scale = scale || ".5"; 2.8569 + 2.8570 + // Adjust and apply 2.8571 + start = start / scale; 2.8572 + jQuery.style( tween.elem, prop, start + unit ); 2.8573 + 2.8574 + // Update scale, tolerating zero or NaN from tween.cur() 2.8575 + // And breaking the loop if scale is unchanged or perfect, or if we've just had enough 2.8576 + } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations ); 2.8577 + } 2.8578 + 2.8579 + tween.unit = unit; 2.8580 + tween.start = start; 2.8581 + // If a +=/-= token was provided, we're doing a relative animation 2.8582 + tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end; 2.8583 + } 2.8584 + return tween; 2.8585 + }] 2.8586 + }; 2.8587 + 2.8588 +// Animations created synchronously will run synchronously 2.8589 +function createFxNow() { 2.8590 + setTimeout(function() { 2.8591 + fxNow = undefined; 2.8592 + }, 0 ); 2.8593 + return ( fxNow = jQuery.now() ); 2.8594 +} 2.8595 + 2.8596 +function createTweens( animation, props ) { 2.8597 + jQuery.each( props, function( prop, value ) { 2.8598 + var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ), 2.8599 + index = 0, 2.8600 + length = collection.length; 2.8601 + for ( ; index < length; index++ ) { 2.8602 + if ( collection[ index ].call( animation, prop, value ) ) { 2.8603 + 2.8604 + // we're done with this property 2.8605 + return; 2.8606 + } 2.8607 + } 2.8608 + }); 2.8609 +} 2.8610 + 2.8611 +function Animation( elem, properties, options ) { 2.8612 + var result, 2.8613 + index = 0, 2.8614 + tweenerIndex = 0, 2.8615 + length = animationPrefilters.length, 2.8616 + deferred = jQuery.Deferred().always( function() { 2.8617 + // don't match elem in the :animated selector 2.8618 + delete tick.elem; 2.8619 + }), 2.8620 + tick = function() { 2.8621 + var currentTime = fxNow || createFxNow(), 2.8622 + remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), 2.8623 + percent = 1 - ( remaining / animation.duration || 0 ), 2.8624 + index = 0, 2.8625 + length = animation.tweens.length; 2.8626 + 2.8627 + for ( ; index < length ; index++ ) { 2.8628 + animation.tweens[ index ].run( percent ); 2.8629 + } 2.8630 + 2.8631 + deferred.notifyWith( elem, [ animation, percent, remaining ]); 2.8632 + 2.8633 + if ( percent < 1 && length ) { 2.8634 + return remaining; 2.8635 + } else { 2.8636 + deferred.resolveWith( elem, [ animation ] ); 2.8637 + return false; 2.8638 + } 2.8639 + }, 2.8640 + animation = deferred.promise({ 2.8641 + elem: elem, 2.8642 + props: jQuery.extend( {}, properties ), 2.8643 + opts: jQuery.extend( true, { specialEasing: {} }, options ), 2.8644 + originalProperties: properties, 2.8645 + originalOptions: options, 2.8646 + startTime: fxNow || createFxNow(), 2.8647 + duration: options.duration, 2.8648 + tweens: [], 2.8649 + createTween: function( prop, end, easing ) { 2.8650 + var tween = jQuery.Tween( elem, animation.opts, prop, end, 2.8651 + animation.opts.specialEasing[ prop ] || animation.opts.easing ); 2.8652 + animation.tweens.push( tween ); 2.8653 + return tween; 2.8654 + }, 2.8655 + stop: function( gotoEnd ) { 2.8656 + var index = 0, 2.8657 + // if we are going to the end, we want to run all the tweens 2.8658 + // otherwise we skip this part 2.8659 + length = gotoEnd ? animation.tweens.length : 0; 2.8660 + 2.8661 + for ( ; index < length ; index++ ) { 2.8662 + animation.tweens[ index ].run( 1 ); 2.8663 + } 2.8664 + 2.8665 + // resolve when we played the last frame 2.8666 + // otherwise, reject 2.8667 + if ( gotoEnd ) { 2.8668 + deferred.resolveWith( elem, [ animation, gotoEnd ] ); 2.8669 + } else { 2.8670 + deferred.rejectWith( elem, [ animation, gotoEnd ] ); 2.8671 + } 2.8672 + return this; 2.8673 + } 2.8674 + }), 2.8675 + props = animation.props; 2.8676 + 2.8677 + propFilter( props, animation.opts.specialEasing ); 2.8678 + 2.8679 + for ( ; index < length ; index++ ) { 2.8680 + result = animationPrefilters[ index ].call( animation, elem, props, animation.opts ); 2.8681 + if ( result ) { 2.8682 + return result; 2.8683 + } 2.8684 + } 2.8685 + 2.8686 + createTweens( animation, props ); 2.8687 + 2.8688 + if ( jQuery.isFunction( animation.opts.start ) ) { 2.8689 + animation.opts.start.call( elem, animation ); 2.8690 + } 2.8691 + 2.8692 + jQuery.fx.timer( 2.8693 + jQuery.extend( tick, { 2.8694 + anim: animation, 2.8695 + queue: animation.opts.queue, 2.8696 + elem: elem 2.8697 + }) 2.8698 + ); 2.8699 + 2.8700 + // attach callbacks from options 2.8701 + return animation.progress( animation.opts.progress ) 2.8702 + .done( animation.opts.done, animation.opts.complete ) 2.8703 + .fail( animation.opts.fail ) 2.8704 + .always( animation.opts.always ); 2.8705 +} 2.8706 + 2.8707 +function propFilter( props, specialEasing ) { 2.8708 + var index, name, easing, value, hooks; 2.8709 + 2.8710 + // camelCase, specialEasing and expand cssHook pass 2.8711 + for ( index in props ) { 2.8712 + name = jQuery.camelCase( index ); 2.8713 + easing = specialEasing[ name ]; 2.8714 + value = props[ index ]; 2.8715 + if ( jQuery.isArray( value ) ) { 2.8716 + easing = value[ 1 ]; 2.8717 + value = props[ index ] = value[ 0 ]; 2.8718 + } 2.8719 + 2.8720 + if ( index !== name ) { 2.8721 + props[ name ] = value; 2.8722 + delete props[ index ]; 2.8723 + } 2.8724 + 2.8725 + hooks = jQuery.cssHooks[ name ]; 2.8726 + if ( hooks && "expand" in hooks ) { 2.8727 + value = hooks.expand( value ); 2.8728 + delete props[ name ]; 2.8729 + 2.8730 + // not quite $.extend, this wont overwrite keys already present. 2.8731 + // also - reusing 'index' from above because we have the correct "name" 2.8732 + for ( index in value ) { 2.8733 + if ( !( index in props ) ) { 2.8734 + props[ index ] = value[ index ]; 2.8735 + specialEasing[ index ] = easing; 2.8736 + } 2.8737 + } 2.8738 + } else { 2.8739 + specialEasing[ name ] = easing; 2.8740 + } 2.8741 + } 2.8742 +} 2.8743 + 2.8744 +jQuery.Animation = jQuery.extend( Animation, { 2.8745 + 2.8746 + tweener: function( props, callback ) { 2.8747 + if ( jQuery.isFunction( props ) ) { 2.8748 + callback = props; 2.8749 + props = [ "*" ]; 2.8750 + } else { 2.8751 + props = props.split(" "); 2.8752 + } 2.8753 + 2.8754 + var prop, 2.8755 + index = 0, 2.8756 + length = props.length; 2.8757 + 2.8758 + for ( ; index < length ; index++ ) { 2.8759 + prop = props[ index ]; 2.8760 + tweeners[ prop ] = tweeners[ prop ] || []; 2.8761 + tweeners[ prop ].unshift( callback ); 2.8762 + } 2.8763 + }, 2.8764 + 2.8765 + prefilter: function( callback, prepend ) { 2.8766 + if ( prepend ) { 2.8767 + animationPrefilters.unshift( callback ); 2.8768 + } else { 2.8769 + animationPrefilters.push( callback ); 2.8770 + } 2.8771 + } 2.8772 +}); 2.8773 + 2.8774 +function defaultPrefilter( elem, props, opts ) { 2.8775 + var index, prop, value, length, dataShow, tween, hooks, oldfire, 2.8776 + anim = this, 2.8777 + style = elem.style, 2.8778 + orig = {}, 2.8779 + handled = [], 2.8780 + hidden = elem.nodeType && isHidden( elem ); 2.8781 + 2.8782 + // handle queue: false promises 2.8783 + if ( !opts.queue ) { 2.8784 + hooks = jQuery._queueHooks( elem, "fx" ); 2.8785 + if ( hooks.unqueued == null ) { 2.8786 + hooks.unqueued = 0; 2.8787 + oldfire = hooks.empty.fire; 2.8788 + hooks.empty.fire = function() { 2.8789 + if ( !hooks.unqueued ) { 2.8790 + oldfire(); 2.8791 + } 2.8792 + }; 2.8793 + } 2.8794 + hooks.unqueued++; 2.8795 + 2.8796 + anim.always(function() { 2.8797 + // doing this makes sure that the complete handler will be called 2.8798 + // before this completes 2.8799 + anim.always(function() { 2.8800 + hooks.unqueued--; 2.8801 + if ( !jQuery.queue( elem, "fx" ).length ) { 2.8802 + hooks.empty.fire(); 2.8803 + } 2.8804 + }); 2.8805 + }); 2.8806 + } 2.8807 + 2.8808 + // height/width overflow pass 2.8809 + if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) { 2.8810 + // Make sure that nothing sneaks out 2.8811 + // Record all 3 overflow attributes because IE does not 2.8812 + // change the overflow attribute when overflowX and 2.8813 + // overflowY are set to the same value 2.8814 + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; 2.8815 + 2.8816 + // Set display property to inline-block for height/width 2.8817 + // animations on inline elements that are having width/height animated 2.8818 + if ( jQuery.css( elem, "display" ) === "inline" && 2.8819 + jQuery.css( elem, "float" ) === "none" ) { 2.8820 + 2.8821 + // inline-level elements accept inline-block; 2.8822 + // block-level elements need to be inline with layout 2.8823 + if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) { 2.8824 + style.display = "inline-block"; 2.8825 + 2.8826 + } else { 2.8827 + style.zoom = 1; 2.8828 + } 2.8829 + } 2.8830 + } 2.8831 + 2.8832 + if ( opts.overflow ) { 2.8833 + style.overflow = "hidden"; 2.8834 + if ( !jQuery.support.shrinkWrapBlocks ) { 2.8835 + anim.done(function() { 2.8836 + style.overflow = opts.overflow[ 0 ]; 2.8837 + style.overflowX = opts.overflow[ 1 ]; 2.8838 + style.overflowY = opts.overflow[ 2 ]; 2.8839 + }); 2.8840 + } 2.8841 + } 2.8842 + 2.8843 + 2.8844 + // show/hide pass 2.8845 + for ( index in props ) { 2.8846 + value = props[ index ]; 2.8847 + if ( rfxtypes.exec( value ) ) { 2.8848 + delete props[ index ]; 2.8849 + if ( value === ( hidden ? "hide" : "show" ) ) { 2.8850 + continue; 2.8851 + } 2.8852 + handled.push( index ); 2.8853 + } 2.8854 + } 2.8855 + 2.8856 + length = handled.length; 2.8857 + if ( length ) { 2.8858 + dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} ); 2.8859 + if ( hidden ) { 2.8860 + jQuery( elem ).show(); 2.8861 + } else { 2.8862 + anim.done(function() { 2.8863 + jQuery( elem ).hide(); 2.8864 + }); 2.8865 + } 2.8866 + anim.done(function() { 2.8867 + var prop; 2.8868 + jQuery.removeData( elem, "fxshow", true ); 2.8869 + for ( prop in orig ) { 2.8870 + jQuery.style( elem, prop, orig[ prop ] ); 2.8871 + } 2.8872 + }); 2.8873 + for ( index = 0 ; index < length ; index++ ) { 2.8874 + prop = handled[ index ]; 2.8875 + tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 ); 2.8876 + orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop ); 2.8877 + 2.8878 + if ( !( prop in dataShow ) ) { 2.8879 + dataShow[ prop ] = tween.start; 2.8880 + if ( hidden ) { 2.8881 + tween.end = tween.start; 2.8882 + tween.start = prop === "width" || prop === "height" ? 1 : 0; 2.8883 + } 2.8884 + } 2.8885 + } 2.8886 + } 2.8887 +} 2.8888 + 2.8889 +function Tween( elem, options, prop, end, easing ) { 2.8890 + return new Tween.prototype.init( elem, options, prop, end, easing ); 2.8891 +} 2.8892 +jQuery.Tween = Tween; 2.8893 + 2.8894 +Tween.prototype = { 2.8895 + constructor: Tween, 2.8896 + init: function( elem, options, prop, end, easing, unit ) { 2.8897 + this.elem = elem; 2.8898 + this.prop = prop; 2.8899 + this.easing = easing || "swing"; 2.8900 + this.options = options; 2.8901 + this.start = this.now = this.cur(); 2.8902 + this.end = end; 2.8903 + this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 2.8904 + }, 2.8905 + cur: function() { 2.8906 + var hooks = Tween.propHooks[ this.prop ]; 2.8907 + 2.8908 + return hooks && hooks.get ? 2.8909 + hooks.get( this ) : 2.8910 + Tween.propHooks._default.get( this ); 2.8911 + }, 2.8912 + run: function( percent ) { 2.8913 + var eased, 2.8914 + hooks = Tween.propHooks[ this.prop ]; 2.8915 + 2.8916 + if ( this.options.duration ) { 2.8917 + this.pos = eased = jQuery.easing[ this.easing ]( 2.8918 + percent, this.options.duration * percent, 0, 1, this.options.duration 2.8919 + ); 2.8920 + } else { 2.8921 + this.pos = eased = percent; 2.8922 + } 2.8923 + this.now = ( this.end - this.start ) * eased + this.start; 2.8924 + 2.8925 + if ( this.options.step ) { 2.8926 + this.options.step.call( this.elem, this.now, this ); 2.8927 + } 2.8928 + 2.8929 + if ( hooks && hooks.set ) { 2.8930 + hooks.set( this ); 2.8931 + } else { 2.8932 + Tween.propHooks._default.set( this ); 2.8933 + } 2.8934 + return this; 2.8935 + } 2.8936 +}; 2.8937 + 2.8938 +Tween.prototype.init.prototype = Tween.prototype; 2.8939 + 2.8940 +Tween.propHooks = { 2.8941 + _default: { 2.8942 + get: function( tween ) { 2.8943 + var result; 2.8944 + 2.8945 + if ( tween.elem[ tween.prop ] != null && 2.8946 + (!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) { 2.8947 + return tween.elem[ tween.prop ]; 2.8948 + } 2.8949 + 2.8950 + // passing any value as a 4th parameter to .css will automatically 2.8951 + // attempt a parseFloat and fallback to a string if the parse fails 2.8952 + // so, simple values such as "10px" are parsed to Float. 2.8953 + // complex values such as "rotate(1rad)" are returned as is. 2.8954 + result = jQuery.css( tween.elem, tween.prop, false, "" ); 2.8955 + // Empty strings, null, undefined and "auto" are converted to 0. 2.8956 + return !result || result === "auto" ? 0 : result; 2.8957 + }, 2.8958 + set: function( tween ) { 2.8959 + // use step hook for back compat - use cssHook if its there - use .style if its 2.8960 + // available and use plain properties where available 2.8961 + if ( jQuery.fx.step[ tween.prop ] ) { 2.8962 + jQuery.fx.step[ tween.prop ]( tween ); 2.8963 + } else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) { 2.8964 + jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); 2.8965 + } else { 2.8966 + tween.elem[ tween.prop ] = tween.now; 2.8967 + } 2.8968 + } 2.8969 + } 2.8970 +}; 2.8971 + 2.8972 +// Remove in 2.0 - this supports IE8's panic based approach 2.8973 +// to setting things on disconnected nodes 2.8974 + 2.8975 +Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 2.8976 + set: function( tween ) { 2.8977 + if ( tween.elem.nodeType && tween.elem.parentNode ) { 2.8978 + tween.elem[ tween.prop ] = tween.now; 2.8979 + } 2.8980 + } 2.8981 +}; 2.8982 + 2.8983 +jQuery.each([ "toggle", "show", "hide" ], function( i, name ) { 2.8984 + var cssFn = jQuery.fn[ name ]; 2.8985 + jQuery.fn[ name ] = function( speed, easing, callback ) { 2.8986 + return speed == null || typeof speed === "boolean" || 2.8987 + // special check for .toggle( handler, handler, ... ) 2.8988 + ( !i && jQuery.isFunction( speed ) && jQuery.isFunction( easing ) ) ? 2.8989 + cssFn.apply( this, arguments ) : 2.8990 + this.animate( genFx( name, true ), speed, easing, callback ); 2.8991 + }; 2.8992 +}); 2.8993 + 2.8994 +jQuery.fn.extend({ 2.8995 + fadeTo: function( speed, to, easing, callback ) { 2.8996 + 2.8997 + // show any hidden elements after setting opacity to 0 2.8998 + return this.filter( isHidden ).css( "opacity", 0 ).show() 2.8999 + 2.9000 + // animate to the value specified 2.9001 + .end().animate({ opacity: to }, speed, easing, callback ); 2.9002 + }, 2.9003 + animate: function( prop, speed, easing, callback ) { 2.9004 + var empty = jQuery.isEmptyObject( prop ), 2.9005 + optall = jQuery.speed( speed, easing, callback ), 2.9006 + doAnimation = function() { 2.9007 + // Operate on a copy of prop so per-property easing won't be lost 2.9008 + var anim = Animation( this, jQuery.extend( {}, prop ), optall ); 2.9009 + 2.9010 + // Empty animations resolve immediately 2.9011 + if ( empty ) { 2.9012 + anim.stop( true ); 2.9013 + } 2.9014 + }; 2.9015 + 2.9016 + return empty || optall.queue === false ? 2.9017 + this.each( doAnimation ) : 2.9018 + this.queue( optall.queue, doAnimation ); 2.9019 + }, 2.9020 + stop: function( type, clearQueue, gotoEnd ) { 2.9021 + var stopQueue = function( hooks ) { 2.9022 + var stop = hooks.stop; 2.9023 + delete hooks.stop; 2.9024 + stop( gotoEnd ); 2.9025 + }; 2.9026 + 2.9027 + if ( typeof type !== "string" ) { 2.9028 + gotoEnd = clearQueue; 2.9029 + clearQueue = type; 2.9030 + type = undefined; 2.9031 + } 2.9032 + if ( clearQueue && type !== false ) { 2.9033 + this.queue( type || "fx", [] ); 2.9034 + } 2.9035 + 2.9036 + return this.each(function() { 2.9037 + var dequeue = true, 2.9038 + index = type != null && type + "queueHooks", 2.9039 + timers = jQuery.timers, 2.9040 + data = jQuery._data( this ); 2.9041 + 2.9042 + if ( index ) { 2.9043 + if ( data[ index ] && data[ index ].stop ) { 2.9044 + stopQueue( data[ index ] ); 2.9045 + } 2.9046 + } else { 2.9047 + for ( index in data ) { 2.9048 + if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { 2.9049 + stopQueue( data[ index ] ); 2.9050 + } 2.9051 + } 2.9052 + } 2.9053 + 2.9054 + for ( index = timers.length; index--; ) { 2.9055 + if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) { 2.9056 + timers[ index ].anim.stop( gotoEnd ); 2.9057 + dequeue = false; 2.9058 + timers.splice( index, 1 ); 2.9059 + } 2.9060 + } 2.9061 + 2.9062 + // start the next in the queue if the last step wasn't forced 2.9063 + // timers currently will call their complete callbacks, which will dequeue 2.9064 + // but only if they were gotoEnd 2.9065 + if ( dequeue || !gotoEnd ) { 2.9066 + jQuery.dequeue( this, type ); 2.9067 + } 2.9068 + }); 2.9069 + } 2.9070 +}); 2.9071 + 2.9072 +// Generate parameters to create a standard animation 2.9073 +function genFx( type, includeWidth ) { 2.9074 + var which, 2.9075 + attrs = { height: type }, 2.9076 + i = 0; 2.9077 + 2.9078 + // if we include width, step value is 1 to do all cssExpand values, 2.9079 + // if we don't include width, step value is 2 to skip over Left and Right 2.9080 + includeWidth = includeWidth? 1 : 0; 2.9081 + for( ; i < 4 ; i += 2 - includeWidth ) { 2.9082 + which = cssExpand[ i ]; 2.9083 + attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; 2.9084 + } 2.9085 + 2.9086 + if ( includeWidth ) { 2.9087 + attrs.opacity = attrs.width = type; 2.9088 + } 2.9089 + 2.9090 + return attrs; 2.9091 +} 2.9092 + 2.9093 +// Generate shortcuts for custom animations 2.9094 +jQuery.each({ 2.9095 + slideDown: genFx("show"), 2.9096 + slideUp: genFx("hide"), 2.9097 + slideToggle: genFx("toggle"), 2.9098 + fadeIn: { opacity: "show" }, 2.9099 + fadeOut: { opacity: "hide" }, 2.9100 + fadeToggle: { opacity: "toggle" } 2.9101 +}, function( name, props ) { 2.9102 + jQuery.fn[ name ] = function( speed, easing, callback ) { 2.9103 + return this.animate( props, speed, easing, callback ); 2.9104 + }; 2.9105 +}); 2.9106 + 2.9107 +jQuery.speed = function( speed, easing, fn ) { 2.9108 + var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { 2.9109 + complete: fn || !fn && easing || 2.9110 + jQuery.isFunction( speed ) && speed, 2.9111 + duration: speed, 2.9112 + easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing 2.9113 + }; 2.9114 + 2.9115 + opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration : 2.9116 + opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default; 2.9117 + 2.9118 + // normalize opt.queue - true/undefined/null -> "fx" 2.9119 + if ( opt.queue == null || opt.queue === true ) { 2.9120 + opt.queue = "fx"; 2.9121 + } 2.9122 + 2.9123 + // Queueing 2.9124 + opt.old = opt.complete; 2.9125 + 2.9126 + opt.complete = function() { 2.9127 + if ( jQuery.isFunction( opt.old ) ) { 2.9128 + opt.old.call( this ); 2.9129 + } 2.9130 + 2.9131 + if ( opt.queue ) { 2.9132 + jQuery.dequeue( this, opt.queue ); 2.9133 + } 2.9134 + }; 2.9135 + 2.9136 + return opt; 2.9137 +}; 2.9138 + 2.9139 +jQuery.easing = { 2.9140 + linear: function( p ) { 2.9141 + return p; 2.9142 + }, 2.9143 + swing: function( p ) { 2.9144 + return 0.5 - Math.cos( p*Math.PI ) / 2; 2.9145 + } 2.9146 +}; 2.9147 + 2.9148 +jQuery.timers = []; 2.9149 +jQuery.fx = Tween.prototype.init; 2.9150 +jQuery.fx.tick = function() { 2.9151 + var timer, 2.9152 + timers = jQuery.timers, 2.9153 + i = 0; 2.9154 + 2.9155 + for ( ; i < timers.length; i++ ) { 2.9156 + timer = timers[ i ]; 2.9157 + // Checks the timer has not already been removed 2.9158 + if ( !timer() && timers[ i ] === timer ) { 2.9159 + timers.splice( i--, 1 ); 2.9160 + } 2.9161 + } 2.9162 + 2.9163 + if ( !timers.length ) { 2.9164 + jQuery.fx.stop(); 2.9165 + } 2.9166 +}; 2.9167 + 2.9168 +jQuery.fx.timer = function( timer ) { 2.9169 + if ( timer() && jQuery.timers.push( timer ) && !timerId ) { 2.9170 + timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval ); 2.9171 + } 2.9172 +}; 2.9173 + 2.9174 +jQuery.fx.interval = 13; 2.9175 + 2.9176 +jQuery.fx.stop = function() { 2.9177 + clearInterval( timerId ); 2.9178 + timerId = null; 2.9179 +}; 2.9180 + 2.9181 +jQuery.fx.speeds = { 2.9182 + slow: 600, 2.9183 + fast: 200, 2.9184 + // Default speed 2.9185 + _default: 400 2.9186 +}; 2.9187 + 2.9188 +// Back Compat <1.8 extension point 2.9189 +jQuery.fx.step = {}; 2.9190 + 2.9191 +if ( jQuery.expr && jQuery.expr.filters ) { 2.9192 + jQuery.expr.filters.animated = function( elem ) { 2.9193 + return jQuery.grep(jQuery.timers, function( fn ) { 2.9194 + return elem === fn.elem; 2.9195 + }).length; 2.9196 + }; 2.9197 +} 2.9198 +var rroot = /^(?:body|html)$/i; 2.9199 + 2.9200 +jQuery.fn.offset = function( options ) { 2.9201 + if ( arguments.length ) { 2.9202 + return options === undefined ? 2.9203 + this : 2.9204 + this.each(function( i ) { 2.9205 + jQuery.offset.setOffset( this, options, i ); 2.9206 + }); 2.9207 + } 2.9208 + 2.9209 + var docElem, body, win, clientTop, clientLeft, scrollTop, scrollLeft, 2.9210 + box = { top: 0, left: 0 }, 2.9211 + elem = this[ 0 ], 2.9212 + doc = elem && elem.ownerDocument; 2.9213 + 2.9214 + if ( !doc ) { 2.9215 + return; 2.9216 + } 2.9217 + 2.9218 + if ( (body = doc.body) === elem ) { 2.9219 + return jQuery.offset.bodyOffset( elem ); 2.9220 + } 2.9221 + 2.9222 + docElem = doc.documentElement; 2.9223 + 2.9224 + // Make sure it's not a disconnected DOM node 2.9225 + if ( !jQuery.contains( docElem, elem ) ) { 2.9226 + return box; 2.9227 + } 2.9228 + 2.9229 + // If we don't have gBCR, just use 0,0 rather than error 2.9230 + // BlackBerry 5, iOS 3 (original iPhone) 2.9231 + if ( typeof elem.getBoundingClientRect !== "undefined" ) { 2.9232 + box = elem.getBoundingClientRect(); 2.9233 + } 2.9234 + win = getWindow( doc ); 2.9235 + clientTop = docElem.clientTop || body.clientTop || 0; 2.9236 + clientLeft = docElem.clientLeft || body.clientLeft || 0; 2.9237 + scrollTop = win.pageYOffset || docElem.scrollTop; 2.9238 + scrollLeft = win.pageXOffset || docElem.scrollLeft; 2.9239 + return { 2.9240 + top: box.top + scrollTop - clientTop, 2.9241 + left: box.left + scrollLeft - clientLeft 2.9242 + }; 2.9243 +}; 2.9244 + 2.9245 +jQuery.offset = { 2.9246 + 2.9247 + bodyOffset: function( body ) { 2.9248 + var top = body.offsetTop, 2.9249 + left = body.offsetLeft; 2.9250 + 2.9251 + if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) { 2.9252 + top += parseFloat( jQuery.css(body, "marginTop") ) || 0; 2.9253 + left += parseFloat( jQuery.css(body, "marginLeft") ) || 0; 2.9254 + } 2.9255 + 2.9256 + return { top: top, left: left }; 2.9257 + }, 2.9258 + 2.9259 + setOffset: function( elem, options, i ) { 2.9260 + var position = jQuery.css( elem, "position" ); 2.9261 + 2.9262 + // set position first, in-case top/left are set even on static elem 2.9263 + if ( position === "static" ) { 2.9264 + elem.style.position = "relative"; 2.9265 + } 2.9266 + 2.9267 + var curElem = jQuery( elem ), 2.9268 + curOffset = curElem.offset(), 2.9269 + curCSSTop = jQuery.css( elem, "top" ), 2.9270 + curCSSLeft = jQuery.css( elem, "left" ), 2.9271 + calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1, 2.9272 + props = {}, curPosition = {}, curTop, curLeft; 2.9273 + 2.9274 + // need to be able to calculate position if either top or left is auto and position is either absolute or fixed 2.9275 + if ( calculatePosition ) { 2.9276 + curPosition = curElem.position(); 2.9277 + curTop = curPosition.top; 2.9278 + curLeft = curPosition.left; 2.9279 + } else { 2.9280 + curTop = parseFloat( curCSSTop ) || 0; 2.9281 + curLeft = parseFloat( curCSSLeft ) || 0; 2.9282 + } 2.9283 + 2.9284 + if ( jQuery.isFunction( options ) ) { 2.9285 + options = options.call( elem, i, curOffset ); 2.9286 + } 2.9287 + 2.9288 + if ( options.top != null ) { 2.9289 + props.top = ( options.top - curOffset.top ) + curTop; 2.9290 + } 2.9291 + if ( options.left != null ) { 2.9292 + props.left = ( options.left - curOffset.left ) + curLeft; 2.9293 + } 2.9294 + 2.9295 + if ( "using" in options ) { 2.9296 + options.using.call( elem, props ); 2.9297 + } else { 2.9298 + curElem.css( props ); 2.9299 + } 2.9300 + } 2.9301 +}; 2.9302 + 2.9303 + 2.9304 +jQuery.fn.extend({ 2.9305 + 2.9306 + position: function() { 2.9307 + if ( !this[0] ) { 2.9308 + return; 2.9309 + } 2.9310 + 2.9311 + var elem = this[0], 2.9312 + 2.9313 + // Get *real* offsetParent 2.9314 + offsetParent = this.offsetParent(), 2.9315 + 2.9316 + // Get correct offsets 2.9317 + offset = this.offset(), 2.9318 + parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset(); 2.9319 + 2.9320 + // Subtract element margins 2.9321 + // note: when an element has margin: auto the offsetLeft and marginLeft 2.9322 + // are the same in Safari causing offset.left to incorrectly be 0 2.9323 + offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0; 2.9324 + offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0; 2.9325 + 2.9326 + // Add offsetParent borders 2.9327 + parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0; 2.9328 + parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0; 2.9329 + 2.9330 + // Subtract the two offsets 2.9331 + return { 2.9332 + top: offset.top - parentOffset.top, 2.9333 + left: offset.left - parentOffset.left 2.9334 + }; 2.9335 + }, 2.9336 + 2.9337 + offsetParent: function() { 2.9338 + return this.map(function() { 2.9339 + var offsetParent = this.offsetParent || document.body; 2.9340 + while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) { 2.9341 + offsetParent = offsetParent.offsetParent; 2.9342 + } 2.9343 + return offsetParent || document.body; 2.9344 + }); 2.9345 + } 2.9346 +}); 2.9347 + 2.9348 + 2.9349 +// Create scrollLeft and scrollTop methods 2.9350 +jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) { 2.9351 + var top = /Y/.test( prop ); 2.9352 + 2.9353 + jQuery.fn[ method ] = function( val ) { 2.9354 + return jQuery.access( this, function( elem, method, val ) { 2.9355 + var win = getWindow( elem ); 2.9356 + 2.9357 + if ( val === undefined ) { 2.9358 + return win ? (prop in win) ? win[ prop ] : 2.9359 + win.document.documentElement[ method ] : 2.9360 + elem[ method ]; 2.9361 + } 2.9362 + 2.9363 + if ( win ) { 2.9364 + win.scrollTo( 2.9365 + !top ? val : jQuery( win ).scrollLeft(), 2.9366 + top ? val : jQuery( win ).scrollTop() 2.9367 + ); 2.9368 + 2.9369 + } else { 2.9370 + elem[ method ] = val; 2.9371 + } 2.9372 + }, method, val, arguments.length, null ); 2.9373 + }; 2.9374 +}); 2.9375 + 2.9376 +function getWindow( elem ) { 2.9377 + return jQuery.isWindow( elem ) ? 2.9378 + elem : 2.9379 + elem.nodeType === 9 ? 2.9380 + elem.defaultView || elem.parentWindow : 2.9381 + false; 2.9382 +} 2.9383 +// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 2.9384 +jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { 2.9385 + jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) { 2.9386 + // margin is only for outerHeight, outerWidth 2.9387 + jQuery.fn[ funcName ] = function( margin, value ) { 2.9388 + var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), 2.9389 + extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); 2.9390 + 2.9391 + return jQuery.access( this, function( elem, type, value ) { 2.9392 + var doc; 2.9393 + 2.9394 + if ( jQuery.isWindow( elem ) ) { 2.9395 + // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there 2.9396 + // isn't a whole lot we can do. See pull request at this URL for discussion: 2.9397 + // https://github.com/jquery/jquery/pull/764 2.9398 + return elem.document.documentElement[ "client" + name ]; 2.9399 + } 2.9400 + 2.9401 + // Get document width or height 2.9402 + if ( elem.nodeType === 9 ) { 2.9403 + doc = elem.documentElement; 2.9404 + 2.9405 + // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest 2.9406 + // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it. 2.9407 + return Math.max( 2.9408 + elem.body[ "scroll" + name ], doc[ "scroll" + name ], 2.9409 + elem.body[ "offset" + name ], doc[ "offset" + name ], 2.9410 + doc[ "client" + name ] 2.9411 + ); 2.9412 + } 2.9413 + 2.9414 + return value === undefined ? 2.9415 + // Get width or height on the element, requesting but not forcing parseFloat 2.9416 + jQuery.css( elem, type, value, extra ) : 2.9417 + 2.9418 + // Set width or height on the element 2.9419 + jQuery.style( elem, type, value, extra ); 2.9420 + }, type, chainable ? margin : undefined, chainable, null ); 2.9421 + }; 2.9422 + }); 2.9423 +}); 2.9424 +// Expose jQuery to the global object 2.9425 +window.jQuery = window.$ = jQuery; 2.9426 + 2.9427 +// Expose jQuery as an AMD module, but only for AMD loaders that 2.9428 +// understand the issues with loading multiple versions of jQuery 2.9429 +// in a page that all might call define(). The loader will indicate 2.9430 +// they have special allowances for multiple jQuery versions by 2.9431 +// specifying define.amd.jQuery = true. Register as a named module, 2.9432 +// since jQuery can be concatenated with other files that may use define, 2.9433 +// but not use a proper concatenation script that understands anonymous 2.9434 +// AMD modules. A named AMD is safest and most robust way to register. 2.9435 +// Lowercase jquery is used because AMD module names are derived from 2.9436 +// file names, and jQuery is normally delivered in a lowercase file name. 2.9437 +// Do this after creating the global so that if an AMD module wants to call 2.9438 +// noConflict to hide this version of jQuery, it will work. 2.9439 +if ( typeof define === "function" && define.amd && define.amd.jQuery ) { 2.9440 + define( "jquery", [], function () { return jQuery; } ); 2.9441 +} 2.9442 + 2.9443 +})( window );
3.1 --- a/endpoint/WebContent/query.jsp Tue Oct 02 15:12:45 2012 +0300 3.2 +++ b/endpoint/WebContent/query.jsp Tue Oct 02 18:35:44 2012 +0300 3.3 @@ -12,6 +12,7 @@ 3.4 <head> 3.5 <meta name="viewport" content="initial-scale=1.0, user-scalable=no" /> 3.6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> 3.7 + <script type="text/javascript" src="js/more_link.js"></script> 3.8 <link rel="stylesheet" href="style.css" type="text/css" /> 3.9 <script type="text/javascript"> 3.10 function toggleMe(a) { 3.11 @@ -27,6 +28,41 @@ 3.12 return true; 3.13 } 3.14 </script> 3.15 + <script> 3.16 + $(document).ready(function() { 3.17 + var showChar = 100; 3.18 + var ellipsestext = "..."; 3.19 + var moretext = "more"; 3.20 + var lesstext = "less"; 3.21 + $('.more').each(function() { 3.22 + var content = $(this).html(); 3.23 + 3.24 + if(content.length > showChar) { 3.25 + 3.26 + var c = content.substr(0, showChar); 3.27 + var h = content.substr(showChar-1, content.length - showChar); 3.28 + 3.29 + var html = c + '<span class="moreelipses">'+ellipsestext+'</span> <span class="morecontent"><span>' + h + '</span> <a href="" class="morelink">'+moretext+'</a></span>'; 3.30 + 3.31 + $(this).html(html); 3.32 + } 3.33 + 3.34 + }); 3.35 + 3.36 + $(".morelink").click(function(){ 3.37 + if($(this).hasClass("less")) { 3.38 + $(this).removeClass("less"); 3.39 + $(this).html(moretext); 3.40 + } else { 3.41 + $(this).addClass("less"); 3.42 + $(this).html(lesstext); 3.43 + } 3.44 + $(this).parent().prev().toggle(); 3.45 + $(this).prev().toggle(); 3.46 + return false; 3.47 + }); 3.48 + }); 3.49 +</script> 3.50 <% 3.51 if (request.getAttribute("pathToKML") != null) { 3.52 if ("map_local".equals(request.getAttribute("handle"))) {
4.1 --- a/endpoint/WebContent/style.css Tue Oct 02 15:12:45 2012 +0300 4.2 +++ b/endpoint/WebContent/style.css Tue Oct 02 18:35:44 2012 +0300 4.3 @@ -201,4 +201,18 @@ 4.4 letter-spacing:.1em; 4.5 text-decoration: none; 4.6 } 4.7 - 4.8 \ No newline at end of file 4.9 + 4.10 +.comment { 4.11 + width: 400px; 4.12 + background-color: #f0f0f0; 4.13 + margin: 10px; 4.14 +} 4.15 +a.morelink { 4.16 + text-decoration:none; 4.17 + outline: none; 4.18 + color: blue; 4.19 +} 4.20 +.morecontent span { 4.21 + display: none; 4.22 + 4.23 +} 4.24 \ No newline at end of file
5.1 --- a/resultio/src/main/java/org/openrdf/query/resultio/sparqlhtml/stSPARQLResultsHTMLWriter.java Tue Oct 02 15:12:45 2012 +0300 5.2 +++ b/resultio/src/main/java/org/openrdf/query/resultio/sparqlhtml/stSPARQLResultsHTMLWriter.java Tue Oct 02 18:35:44 2012 +0300 5.3 @@ -43,6 +43,7 @@ 5.4 public static final String TABLE_HEADER_CLASS = "query_results_header"; 5.5 public static final String TABLE_DATA_CLASS = "query_results_data"; 5.6 public static final String TABLE_CLASS = "query_results_table"; 5.7 + public static final String MORE_LINK = "comment more"; 5.8 5.9 /** 5.10 * The underlying XML formatter. 5.11 @@ -121,13 +122,13 @@ 5.12 if(boundValue instanceof BNode) { 5.13 value.insert(0, "_:"); 5.14 } 5.15 - 5.16 - xmlWriter.setAttribute(STYLE, TABLE_DATA_CLASS); 5.17 - xmlWriter.setAttribute(ID, LINK_ID); 5.18 - xmlWriter.startTag(TABLE_DATA_TAG); 5.19 + 5.20 // If the value is a uri, make it link 5.21 if(boundValue instanceof URI) 5.22 - { 5.23 + { 5.24 + xmlWriter.setAttribute(ID, LINK_ID); 5.25 + xmlWriter.startTag(TABLE_DATA_TAG); 5.26 + 5.27 // select all the triples that contain the boundValue 5.28 String query= "select * " + 5.29 "where " + 5.30 @@ -142,20 +143,20 @@ 5.31 xmlWriter.setAttribute(LINK_REF, href); 5.32 xmlWriter.startTag(LINK); 5.33 xmlWriter.text(boundValue.toString()); 5.34 - xmlWriter.endTag(LINK); 5.35 + xmlWriter.endTag(LINK); 5.36 } 5.37 else 5.38 - { 5.39 + { 5.40 + xmlWriter.setAttribute(STYLE, MORE_LINK); 5.41 + xmlWriter.startTag(TABLE_DATA_TAG); 5.42 xmlWriter.text(boundValue.toString()); 5.43 } 5.44 xmlWriter.endTag(TABLE_DATA_TAG); 5.45 - value.setLength(0); 5.46 - } 5.47 - 5.48 + } 5.49 value.setLength(0); 5.50 } 5.51 + xmlWriter.endTag(TABLE_ROW_TAG); 5.52 5.53 - xmlWriter.endTag(TABLE_ROW_TAG); 5.54 } catch (IOException e) { 5.55 throw new TupleQueryResultHandlerException(e); 5.56 }